diff --git a/app/layouts/LeftSidebar.tsx b/app/layouts/LeftSidebar.tsx
index a781c7f2c..7d6590b52 100644
--- a/app/layouts/LeftSidebar.tsx
+++ b/app/layouts/LeftSidebar.tsx
@@ -10,19 +10,18 @@ import { Logo } from '@/components/ui/Logo';
 import Link from 'next/link';
 import { Icon } from '@/components/ui/icons';
 import { FundingPowerRailButton } from '@/components/Funding/FundingPowerRailButton';
+import { SidebarDocuments } from './components/SidebarDocuments';
 
 interface LeftSidebarProps {
   forceMinimize?: boolean;
   /**
-   * Takes the place of the nav items, the footer links and the funding power
-   * button: a page whose own lists belong in this column. Hidden while the
-   * column is the icon rail, where the page shows them some other way; pass
-   * null to keep the area empty.
+   * Runs once a document or a new draft is picked: on a phone the column is a
+   * menu, and a pick that changes the workspace in place must still close it.
    */
-  content?: React.ReactNode;
+  onNavigate?: () => void;
 }
 
-export const LeftSidebar: React.FC<LeftSidebarProps> = ({ forceMinimize = false, content }) => {
+export const LeftSidebar: React.FC<LeftSidebarProps> = ({ forceMinimize = false, onNavigate }) => {
   const pathname = usePathname();
 
   const handleUnimplementedFeature = (featureName: string) => {
@@ -47,7 +46,6 @@ export const LeftSidebar: React.FC<LeftSidebarProps> = ({ forceMinimize = false,
 
   // Create minimized classes based on either responsive design or forced minimization
   const minimizeClass = forceMinimize ? 'minimized-sidebar' : '';
-  const hasContent = content !== undefined;
 
   return (
     <div className={`h-full flex flex-col z-50 bg-white overflow-hidden ${minimizeClass}`}>
@@ -67,36 +65,36 @@ export const LeftSidebar: React.FC<LeftSidebarProps> = ({ forceMinimize = false,
       <div
         className={`mt-6 px-3 ${forceMinimize ? '!flex !justify-center !px-2' : 'tablet:max-sidebar-compact:!flex tablet:max-sidebar-compact:!justify-center tablet:max-sidebar-compact:!px-2'}`}
       >
-        <PublishMenu forceMinimize={forceMinimize} />
+        <PublishMenu forceMinimize={forceMinimize} onItemSelected={onNavigate} />
       </div>
 
-      {hasContent ? (
-        <div
-          className={`mt-3 min-h-0 flex-1 ${forceMinimize ? '!hidden' : 'tablet:max-sidebar-compact:!hidden'}`}
-        >
-          {content}
-        </div>
-      ) : (
-        <>
-          <Navigation
-            currentPath={pathname || ''}
-            onUnimplementedFeature={handleUnimplementedFeature}
-            forceMinimize={forceMinimize}
-          />
+      {/* The nav and the user's documents scroll together, so a long list
+          never squeezes the nav. The documents hide while the column is the
+          icon rail; the workspace has its own way to them there. */}
+      <div className="min-h-0 flex-1 overflow-y-auto">
+        <Navigation
+          currentPath={pathname || ''}
+          onUnimplementedFeature={handleUnimplementedFeature}
+          forceMinimize={forceMinimize}
+          inScrollArea
+        />
+        <SidebarDocuments
+          onNavigate={onNavigate}
+          className={forceMinimize ? '!hidden' : 'tablet:max-sidebar-compact:!hidden'}
+        />
+      </div>
 
-          {/* Navigation above is flex-1, so this sits at the bottom of the column.
-              Only covers 768px to the right sidebar's breakpoint: below that the
-              bar is docked over the mobile bottom nav, and above it the funding
-              power card is in the right sidebar. */}
-          <div className={`px-2 pb-3 ${forceMinimize ? '!block' : 'hidden tablet:max-lg:!block'}`}>
-            <FundingPowerRailButton />
-          </div>
+      {/* The scroll area above is flex-1, so this sits at the bottom of the column.
+          Only covers 768px to the right sidebar's breakpoint: below that the
+          bar is docked over the mobile bottom nav, and above it the funding
+          power card is in the right sidebar. */}
+      <div className={`px-2 pb-3 ${forceMinimize ? '!block' : 'hidden tablet:max-lg:!block'}`}>
+        <FundingPowerRailButton />
+      </div>
 
-          <div className={forceMinimize ? '!hidden' : 'tablet:max-sidebar-compact:!hidden'}>
-            <FooterLinks />
-          </div>
-        </>
-      )}
+      <div className={forceMinimize ? '!hidden' : 'tablet:max-sidebar-compact:!hidden'}>
+        <FooterLinks />
+      </div>
     </div>
   );
 };
diff --git a/app/layouts/Navigation.tsx b/app/layouts/Navigation.tsx
index bc88bb1c4..1917c5614 100644
--- a/app/layouts/Navigation.tsx
+++ b/app/layouts/Navigation.tsx
@@ -36,6 +36,8 @@ interface NavigationProps {
   currentPath: string;
   onUnimplementedFeature: (featureName: string) => void;
   forceMinimize?: boolean;
+  /** A parent scrolls the nav along with what follows it, so it neither grows nor scrolls itself. */
+  inScrollArea?: boolean;
 }
 
 const navIconMap: Record<NavIconKey, NavIcon> = {
@@ -57,6 +59,7 @@ export const Navigation: React.FC<NavigationProps> = ({
   currentPath,
   onUnimplementedFeature,
   forceMinimize = false,
+  inScrollArea = false,
 }) => {
   const navigationItems: NavigationItem[] = [
     {
@@ -210,7 +213,8 @@ export const Navigation: React.FC<NavigationProps> = ({
     <nav
       aria-label="Primary navigation"
       className={cn(
-        'flex-1 overflow-y-auto px-3 pt-6',
+        'px-3 pt-6',
+        !inScrollArea && 'flex-1 overflow-y-auto',
         forceMinimize ? '!px-2' : 'tablet:max-sidebar-compact:!px-2'
       )}
     >
diff --git a/app/layouts/PageLayout.tsx b/app/layouts/PageLayout.tsx
index 1405e473d..e650654cf 100644
--- a/app/layouts/PageLayout.tsx
+++ b/app/layouts/PageLayout.tsx
@@ -52,11 +52,6 @@ interface PageLayoutProps {
    * of empty space beside the content.
    */
   wideRow?: boolean;
-  /**
-   * Shown in the left column in place of the nav items: a page whose own
-   * lists live there. See `LeftSidebar`'s `content`.
-   */
-  leftSidebarContent?: ReactNode;
   /**
    * The page is an app surface, not a document: it fills the area beside the
    * left column and under the top bar edge to edge and manages its own
@@ -76,7 +71,6 @@ function PageLayoutInner({
   rightSidebarFill = false,
   contentWidth = 'default',
   wideRow = false,
-  leftSidebarContent,
   fullBleed = false,
 }: PageLayoutProps) {
   const isNarrow = contentWidth === 'narrow';
@@ -115,7 +109,7 @@ function PageLayoutInner({
 
         <MobileOverlay show={showOverlay} visible={overlayVisible} onClose={closeLeftSidebar} />
 
-        <LeftSidebarContainer isOpen={isLeftSidebarOpen} content={leftSidebarContent} />
+        <LeftSidebarContainer isOpen={isLeftSidebarOpen} onClose={closeLeftSidebar} />
 
         {fullBleed ? (
           // Offset from the fixed top bar exactly as the scrollport below is,
diff --git a/app/layouts/PublishMenu.tsx b/app/layouts/PublishMenu.tsx
index cce1d9c97..d34699fc9 100644
--- a/app/layouts/PublishMenu.tsx
+++ b/app/layouts/PublishMenu.tsx
@@ -1,21 +1,15 @@
 'use client';
 
-import { ChevronRight, Plus } from 'lucide-react';
-import { useRouter } from 'next/navigation';
-import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
-import { BaseMenu, BaseMenuItem } from '@/components/ui/form/BaseMenu';
-import { FUNDING_KIND_ICON } from '@/components/Funding/fundingKind';
+import { Plus } from 'lucide-react';
+import { BaseMenu } from '@/components/ui/form/BaseMenu';
 import { useAuthenticatedAction } from '@/contexts/AuthModalContext';
 import { SwipeableDrawer } from '@/components/ui/SwipeableDrawer';
 import {
-  OpenFundingOpportunityModal,
-  type FundingOpportunityCreationMethod,
-} from '@/components/Funding/OpenFundingOpportunityModal';
-import {
-  OpenProposalModal,
-  type ProposalCreationMethod,
-} from '@/components/Funding/OpenProposalModal';
-import type { FundingIntent } from '@/components/Funding/fundingDirection';
+  FUNDING_DRAFT_OPTIONS,
+  FundingDraftMenuItems,
+  FundingDraftOptionContent,
+  type FundingDraftOption,
+} from '@/components/Funding/fundingDraftOptions';
 import { useFundingDrafting } from '@/components/Funding/useFundingDrafting';
 import { useScreenSize } from '@/hooks/useScreenSize';
 import { useState } from 'react';
@@ -26,111 +20,22 @@ interface PublishMenuProps {
   onItemSelected?: () => void;
 }
 
-interface PublishMenuItem {
-  readonly id: string;
-  readonly title: string;
-  readonly description: string;
-  readonly icon: React.ReactNode;
-  /** Which side of the money the item starts: an RFP funds, a proposal needs funding. */
-  readonly intent: FundingIntent;
-}
-
-const PUBLISH_MENU_SECTIONS: readonly {
-  readonly title: string;
-  readonly items: readonly PublishMenuItem[];
-}[] = [
-  {
-    title: 'Publish on ResearchHub',
-    items: [
-      {
-        id: 'give-funding',
-        title: 'Request for Proposal',
-        description: 'Fund specific research you care about',
-        icon: (
-          <FontAwesomeIcon
-            icon={FUNDING_KIND_ICON.rfp}
-            className="h-[18px] w-[18px] text-gray-700"
-          />
-        ),
-        intent: 'fund',
-      },
-      {
-        id: 'request-funding',
-        title: 'Proposal',
-        description: 'Raise money for your research',
-        icon: (
-          <FontAwesomeIcon
-            icon={FUNDING_KIND_ICON.proposal}
-            className="h-[18px] w-[18px] text-gray-700"
-          />
-        ),
-        intent: 'need_funding',
-      },
-    ],
-  },
-];
-
-interface MenuItemContentProps {
-  icon: React.ReactNode;
-  title: string;
-  description: string;
-}
-
-const MenuItemContent: React.FC<MenuItemContentProps> = ({ icon, title, description }) => {
-  return (
-    <div className="relative flex w-full items-center gap-3 pr-6">
-      <div className="flex-shrink-0">
-        <div className="flex h-9 w-9 items-center justify-center rounded-lg bg-gray-100 transition-colors duration-150 group-hover:bg-gray-50">
-          {icon}
-        </div>
-      </div>
-      <div className="flex-1 min-w-0">
-        <div className="text-sm font-semibold tracking-[0.01em] text-gray-900">{title}</div>
-        <div className="text-xs text-gray-600">{description}</div>
-      </div>
-      <ChevronRight className="absolute right-0 top-1/2 -translate-y-1/2 h-4 w-4 text-gray-900 transition-opacity duration-200 opacity-0 group-hover:opacity-100" />
-    </div>
-  );
-};
-
 /**
- * The sidebar's Publish button: a Request for Proposal or a Proposal. For a
- * user the workspace admits, either leads straight to a new conversation
- * there for that side of the money; everyone else gets the notebook's
- * opening modal and editor, as before.
+ * The sidebar's Publish button: a Request for Proposal or a Proposal, either
+ * of which leads straight to a new draft in the workspace for that side of
+ * the money.
  */
 export const PublishMenu: React.FC<PublishMenuProps> = ({
   forceMinimize = false,
   onItemSelected,
 }) => {
-  const router = useRouter();
   const { executeAuthenticatedAction } = useAuthenticatedAction();
-  const { inWorkspace, startNew } = useFundingDrafting();
+  const { startNew } = useFundingDrafting();
   const { smAndDown } = useScreenSize();
   const [isMobileDrawerOpen, setIsMobileDrawerOpen] = useState(false);
-  const [isFundingOpportunityModalOpen, setIsFundingOpportunityModalOpen] = useState(false);
-  const [isProposalModalOpen, setIsProposalModalOpen] = useState(false);
 
-  const handleConfirmCreateProposal = (method: ProposalCreationMethod) => {
-    setIsProposalModalOpen(false);
-    router.push(`/notebook?newFunding=true&proposalSource=${method}`);
-  };
-
-  const handleConfirmOpenGrant = (method: FundingOpportunityCreationMethod) => {
-    setIsFundingOpportunityModalOpen(false);
-    router.push(`/notebook?newGrant=true&grantSource=${method}`);
-  };
-
-  const handleMenuItemClick = (item: PublishMenuItem) => {
-    executeAuthenticatedAction(() => {
-      if (inWorkspace) {
-        startNew(item.intent);
-      } else if (item.intent === 'fund') {
-        setIsFundingOpportunityModalOpen(true);
-      } else {
-        setIsProposalModalOpen(true);
-      }
-    });
+  const handleMenuItemClick = (item: FundingDraftOption) => {
+    executeAuthenticatedAction(() => startNew(item.intent));
 
     // Close mobile drawer after action
     if (smAndDown) {
@@ -174,59 +79,27 @@ export const PublishMenu: React.FC<PublishMenuProps> = ({
     </button>
   );
 
-  const menuContent = (
-    <div className="space-y-3">
-      {PUBLISH_MENU_SECTIONS.map((section) => (
-        <div key={section.title}>
-          <div className="space-y-1">
-            {section.items.map((item) => (
-              <BaseMenuItem
-                key={item.id}
-                onClick={() => handleMenuItemClick(item)}
-                className="group w-full cursor-pointer px-2 py-2 rounded-lg transition-colors duration-150 hover:bg-gray-100 focus:bg-gray-100"
-              >
-                <MenuItemContent
-                  icon={item.icon}
-                  title={item.title}
-                  description={item.description}
-                />
-              </BaseMenuItem>
-            ))}
-          </div>
-        </div>
-      ))}
-    </div>
-  );
+  const menuContent = <FundingDraftMenuItems onSelect={handleMenuItemClick} />;
 
   // Mobile drawer content
   const mobileDrawerContent = (
-    <div className="space-y-4">
-      {PUBLISH_MENU_SECTIONS.map((section) => (
-        <div key={section.title}>
-          <div className="space-y-2">
-            {section.items.map((item) => (
-              <div
-                key={item.id}
-                onClick={() => handleMenuItemClick(item)}
-                onKeyDown={(e) => {
-                  if (e.key === 'Enter' || e.key === ' ') {
-                    e.preventDefault();
-                    handleMenuItemClick(item);
-                  }
-                }}
-                className="group w-full px-3 py-3 cursor-pointer rounded-xl transition-colors duration-150 hover:bg-gray-100 active:bg-gray-100"
-                role="button"
-                tabIndex={0}
-                aria-label={`${item.title}: ${item.description}`}
-              >
-                <MenuItemContent
-                  icon={item.icon}
-                  title={item.title}
-                  description={item.description}
-                />
-              </div>
-            ))}
-          </div>
+    <div className="space-y-2">
+      {FUNDING_DRAFT_OPTIONS.map((item) => (
+        <div
+          key={item.id}
+          onClick={() => handleMenuItemClick(item)}
+          onKeyDown={(e) => {
+            if (e.key === 'Enter' || e.key === ' ') {
+              e.preventDefault();
+              handleMenuItemClick(item);
+            }
+          }}
+          className="group w-full px-3 py-3 cursor-pointer rounded-xl transition-colors duration-150 hover:bg-gray-100 active:bg-gray-100"
+          role="button"
+          tabIndex={0}
+          aria-label={`${item.title}: ${item.description}`}
+        >
+          <FundingDraftOptionContent option={item} />
         </div>
       ))}
     </div>
@@ -291,18 +164,6 @@ export const PublishMenu: React.FC<PublishMenuProps> = ({
           </BaseMenu>
         </>
       )}
-
-      <OpenFundingOpportunityModal
-        isOpen={isFundingOpportunityModalOpen}
-        onClose={() => setIsFundingOpportunityModalOpen(false)}
-        onConfirm={handleConfirmOpenGrant}
-      />
-
-      <OpenProposalModal
-        isOpen={isProposalModalOpen}
-        onClose={() => setIsProposalModalOpen(false)}
-        onConfirm={handleConfirmCreateProposal}
-      />
     </div>
   );
 };
diff --git a/app/layouts/components/LeftSidebarContainer.tsx b/app/layouts/components/LeftSidebarContainer.tsx
index a07e832a8..6a69f907f 100644
--- a/app/layouts/components/LeftSidebarContainer.tsx
+++ b/app/layouts/components/LeftSidebarContainer.tsx
@@ -5,11 +5,11 @@ import { LeftSidebar } from '../LeftSidebar';
 
 interface LeftSidebarContainerProps {
   isOpen: boolean;
-  /** Replaces the nav items in the column; see `LeftSidebar`. */
-  content?: React.ReactNode;
+  /** Closes the phone's menu; see `LeftSidebar`'s `onNavigate`. */
+  onClose?: () => void;
 }
 
-export function LeftSidebarContainer({ isOpen, content }: LeftSidebarContainerProps) {
+export function LeftSidebarContainer({ isOpen, onClose }: LeftSidebarContainerProps) {
   return (
     <div
       className={cn(
@@ -26,7 +26,7 @@ export function LeftSidebarContainer({ isOpen, content }: LeftSidebarContainerPr
         isOpen ? '!translate-x-0' : '!-translate-x-full'
       )}
     >
-      <LeftSidebar content={content} />
+      <LeftSidebar onNavigate={onClose} />
     </div>
   );
 }
diff --git a/app/layouts/components/SidebarDocuments.tsx b/app/layouts/components/SidebarDocuments.tsx
new file mode 100644
index 000000000..a2c5e63af
--- /dev/null
+++ b/app/layouts/components/SidebarDocuments.tsx
@@ -0,0 +1,168 @@
+'use client';
+
+import type { ReactNode } from 'react';
+import Link from 'next/link';
+import { FileText, MoveRight, Plus } from 'lucide-react';
+import { useOptionalAIMode } from '@/components/AIMode/AIModeContext';
+import { FundingDraftMenuItems } from '@/components/Funding/fundingDraftOptions';
+import { useFundingDrafting } from '@/components/Funding/useFundingDrafting';
+import { BaseMenu } from '@/components/ui/form/BaseMenu';
+import { useFundingDocuments } from '@/contexts/FundingDocumentsContext';
+import type { Note } from '@/types/note';
+import { cn } from '@/utils/styles';
+import { SidebarRow } from './SidebarRow';
+
+/** Rows shown per section; everything else is a click away in My Funding. */
+const DRAFTS_SHOWN = 8;
+const PUBLISHED_SHOWN = 5;
+
+interface SidebarDocumentsProps {
+  /** Runs after any choice that should put a drawer or an overlay away. */
+  readonly onNavigate?: () => void;
+  /** A rule above the first heading, setting the documents apart from the nav. */
+  readonly divider?: boolean;
+  readonly className?: string;
+}
+
+/**
+ * The user's RFPs and proposals under the app's nav, on every page: what is
+ * still a draft, with a "+" to start another, and what has been published.
+ * Each opens in the workspace; the one open there is highlighted.
+ */
+export function SidebarDocuments({ onNavigate, divider = true, className }: SidebarDocumentsProps) {
+  const { drafts, published, status, refresh } = useFundingDocuments();
+  const { startNew, openDraft } = useFundingDrafting();
+  const target = useOptionalAIMode()?.target;
+  const activeNoteId = target?.kind === 'document' ? target.noteId : null;
+
+  if (status === 'off') return null;
+
+  const open = (note: Note) => {
+    // The open document stays on the chat it is on.
+    if (note.id !== activeNoteId) openDraft(note);
+    onNavigate?.();
+  };
+  const rows = (notes: readonly Note[], shown: number) =>
+    notes
+      // The open document keeps its row, even when it is older than the rest.
+      .filter((note, index) => index < shown || note.id === activeNoteId)
+      .map((note) => (
+        <SidebarRow
+          key={note.id}
+          title={note.title?.trim() || 'Untitled'}
+          leading={<FileText className="h-[15px] w-[15px] shrink-0 text-gray-500" aria-hidden />}
+          isActive={note.id === activeNoteId}
+          onSelect={() => open(note)}
+        />
+      ));
+
+  const ready = status === 'ready';
+  const hasPublished = ready && published.length > 0;
+
+  return (
+    <div className={cn('px-3 pb-3', className)}>
+      {divider ? (
+        <div aria-hidden="true" className="mx-2 mb-3 mt-3.5 h-px bg-gray-200" />
+      ) : (
+        <div className="h-3" />
+      )}
+
+      <section aria-label="Drafts">
+        <SectionHeading
+          action={
+            <BaseMenu
+              align="start"
+              sideOffset={4}
+              className="w-[320px] max-w-[calc(100vw-1rem)] rounded-xl p-1"
+              trigger={
+                <button
+                  type="button"
+                  aria-label="New draft"
+                  title="New draft"
+                  className="flex h-7 w-7 items-center justify-center rounded-md text-gray-500 transition-colors hover:bg-gray-100 hover:text-gray-900"
+                >
+                  <Plus className="h-4 w-4" aria-hidden="true" />
+                </button>
+              }
+            >
+              <FundingDraftMenuItems
+                onSelect={(option) => {
+                  startNew(option.intent);
+                  onNavigate?.();
+                }}
+              />
+            </BaseMenu>
+          }
+        >
+          Drafts
+        </SectionHeading>
+
+        {status === 'loading' ? (
+          <RowsSkeleton />
+        ) : status === 'error' ? (
+          <div className="flex flex-col items-start gap-1 px-2.5 py-1.5">
+            <p className="text-xs text-gray-500">Couldn’t load your documents.</p>
+            <button
+              type="button"
+              onClick={() => void refresh()}
+              className="text-xs font-medium text-primary-600 hover:text-primary-700"
+            >
+              Try again
+            </button>
+          </div>
+        ) : drafts.length === 0 ? (
+          <p className="px-2.5 py-1.5 text-xs text-gray-500">No drafts yet.</p>
+        ) : (
+          rows(drafts, DRAFTS_SHOWN)
+        )}
+      </section>
+
+      {hasPublished && (
+        <section aria-label="Published" className="mt-2">
+          <SectionHeading>Published</SectionHeading>
+          {rows(published, PUBLISHED_SHOWN)}
+        </section>
+      )}
+
+      {ready && (drafts.length > 0 || hasPublished) && (
+        <Link
+          href="/my-funding"
+          onClick={onNavigate}
+          className="ml-2.5 mt-1.5 inline-flex items-center gap-1 text-xs font-medium text-gray-600 transition-colors hover:text-gray-900"
+        >
+          See all
+          <MoveRight className="h-3.5 w-3.5" aria-hidden="true" />
+        </Link>
+      )}
+    </div>
+  );
+}
+
+function SectionHeading({
+  children,
+  action,
+}: {
+  readonly children: ReactNode;
+  readonly action?: ReactNode;
+}) {
+  return (
+    <div className="flex h-8 items-center justify-between pl-2.5">
+      <h2 className="text-xs font-medium text-gray-500">{children}</h2>
+      {action}
+    </div>
+  );
+}
+
+/** Two rows' worth of placeholder: the first load only. */
+function RowsSkeleton() {
+  return (
+    <div aria-hidden="true">
+      {['w-[70%]', 'w-[55%]'].map((width) => (
+        <div key={width} className="flex items-center gap-2.5 px-2.5 py-2">
+          <div className="h-[15px] w-[15px] shrink-0 animate-pulse rounded bg-gray-100" />
+          <div className={cn('h-3 animate-pulse rounded bg-gray-100', width)} />
+        </div>
+      ))}
+    </div>
+  );
+}
diff --git a/app/layouts/components/SidebarRow.tsx b/app/layouts/components/SidebarRow.tsx
new file mode 100644
index 000000000..b835fc97d
--- /dev/null
+++ b/app/layouts/components/SidebarRow.tsx
@@ -0,0 +1,32 @@
+'use client';
+
+import type { ReactNode } from 'react';
+import { cn } from '@/utils/styles';
+
+interface SidebarRowProps {
+  readonly title: string;
+  /** Something before the title: a document's icon. */
+  readonly leading?: ReactNode;
+  readonly isActive: boolean;
+  readonly onSelect: () => void;
+}
+
+/** One entry in a list in the left sidebar: a document, say. */
+export function SidebarRow({ title, leading, isActive, onSelect }: SidebarRowProps) {
+  return (
+    <button
+      type="button"
+      onClick={onSelect}
+      aria-current={isActive ? 'true' : undefined}
+      title={title}
+      className={cn(
+        'mb-0.5 flex w-full items-center gap-2.5 rounded-lg py-2 pr-3 text-left transition-colors',
+        leading ? 'pl-2.5' : 'pl-3',
+        isActive ? 'bg-gray-100' : 'hover:bg-gray-50'
+      )}
+    >
+      {leading}
+      <span className="min-w-0 flex-1 truncate text-[13px] font-medium text-gray-800">{title}</span>
+    </button>
+  );
+}
diff --git a/app/my-funding/components/MyFundingContent.tsx b/app/my-funding/components/MyFundingContent.tsx
index 50b3aa3b6..71680cbf6 100644
--- a/app/my-funding/components/MyFundingContent.tsx
+++ b/app/my-funding/components/MyFundingContent.tsx
@@ -29,7 +29,7 @@ interface MyFundingContentProps {
  * column, as it does on an RFP page.
  */
 export function MyFundingContent({ viewedUserId, isOwnPage, authorId }: MyFundingContentProps) {
-  const { published, drafts, isSettled, error, hasMore, loadMore, refreshDrafts } =
+  const { published, drafts, draftCount, isSettled, error, hasMore, loadMore } =
     useMyFundingDocuments({
       viewedUserId,
       isOwnPage,
@@ -56,7 +56,9 @@ export function MyFundingContent({ viewedUserId, isOwnPage, authorId }: MyFundin
   return (
     <div className="mb-6 space-y-8">
       {error && <MyFundingDataError />}
-      {drafts.length > 0 && <DraftCarousel drafts={drafts} onDeleted={refreshDrafts} />}
+      {drafts.length > 0 && (
+        <DraftCarousel drafts={drafts} count={Math.max(draftCount, drafts.length)} />
+      )}
       <PublishedRows
         documents={published}
         hasMore={hasMore}
diff --git a/app/notebook/[orgSlug]/page.tsx b/app/notebook/[orgSlug]/page.tsx
index 046727ae6..cdae9f313 100644
--- a/app/notebook/[orgSlug]/page.tsx
+++ b/app/notebook/[orgSlug]/page.tsx
@@ -2,17 +2,13 @@
 
 import { useOrganizationContext } from '@/contexts/OrganizationContext';
 import { useNotebookContext } from '@/contexts/NotebookContext';
-import { useEffect } from 'react';
+import { useEffect, useState } from 'react';
 import { useSearchParams, useRouter } from 'next/navigation';
 import proposalTemplate from '@/components/Editor/lib/data/proposalTemplate';
 import { initialContent } from '@/components/Editor/lib/data/initialContent';
 import grantTemplate from '@/components/Editor/lib/data/grantTemplate';
-import {
-  getDocumentTitle,
-  getTemplatePlainText,
-} from '@/components/Editor/lib/utils/documentTitle';
-import { useCreateNote, useNoteContent } from '@/hooks/useNote';
-import { NoteService } from '@/services/note.service';
+import { getDocumentTitle } from '@/components/Editor/lib/utils/documentTitle';
+import { createFundingDraft } from '@/components/Funding/createFundingDraft';
 import { NoteCreationPopover } from '@/components/Notebook/NoteCreationPopover';
 import { useUser } from '@/contexts/UserContext';
 import type { ID } from '@/types/root';
@@ -34,8 +30,7 @@ export default function OrganizationPage() {
   const { user, isLoading: isLoadingUser } = useUser();
   const isModerator = !!user?.isModerator;
 
-  const [{ isLoading: isCreatingNote }, createNote] = useCreateNote();
-  const [{ isLoading: isUpdatingContent }, updateNoteContent] = useNoteContent();
+  const [isCreatingNote, setIsCreatingNote] = useState(false);
 
   const isNewFunding = searchParams.get('newFunding') === 'true';
   const isNewChangelog = searchParams.get('newChangelog') === 'true';
@@ -56,36 +51,28 @@ export default function OrganizationPage() {
       template: typeof proposalTemplate | typeof grantTemplate | typeof initialContent;
       queryParam?: string;
       queryValue?: string;
-      documentType?: string;
+      documentType: string;
       selectedGrantId?: Exclude<ID, null | undefined>;
     }
   ) => {
+    setIsCreatingNote(true);
     try {
-      const title = getDocumentTitle(template) || 'Untitled';
-      const newNote = await createNote({
-        organizationSlug: orgSlug,
-        title,
-        grouping: 'WORKSPACE',
+      const newNote = await createFundingDraft({
+        orgSlug,
+        title: getDocumentTitle(template) || 'Untitled',
         documentType,
+        grouping: 'WORKSPACE',
+        selectedGrantId,
+        template,
       });
 
-      if (newNote) {
-        if (selectedGrantId) {
-          await NoteService.updateNote({ noteId: newNote.id, selectedGrantId });
-        }
-
-        await updateNoteContent({
-          note: newNote.id,
-          fullJson: JSON.stringify(template),
-          plainText: getTemplatePlainText(template),
-        });
-
-        const queryString = queryParam && queryValue ? `?${queryParam}=${queryValue}` : '';
-        refreshNotes();
-        router.replace(`/notebook/${orgSlug}/${newNote.id}${queryString}`);
-      }
+      const queryString = queryParam && queryValue ? `?${queryParam}=${queryValue}` : '';
+      refreshNotes();
+      router.replace(`/notebook/${orgSlug}/${newNote.id}${queryString}`);
     } catch (err) {
       console.error('Failed to create note:', err);
+    } finally {
+      setIsCreatingNote(false);
     }
   };
 
@@ -156,5 +143,5 @@ export default function OrganizationPage() {
     return null;
   }
 
-  return <NoteCreationPopover isOpen={isCreatingNote || isUpdatingContent} />;
+  return <NoteCreationPopover isOpen={isCreatingNote} />;
 }
diff --git a/app/workspace/WorkspaceClient.tsx b/app/workspace/WorkspaceClient.tsx
index f53523452..a560ccbf8 100644
--- a/app/workspace/WorkspaceClient.tsx
+++ b/app/workspace/WorkspaceClient.tsx
@@ -7,7 +7,7 @@ import { PageLayout } from '@/app/layouts/PageLayout';
 /** The app's shell with the workspace's areas empty, until the workspace itself has loaded. */
 function WorkspaceShell() {
   return (
-    <PageLayout fullBleed leftSidebarContent={null}>
+    <PageLayout fullBleed>
       <div className="min-h-0 flex-1 bg-gray-50" />
     </PageLayout>
   );
diff --git a/components/AIMode/AIModeContext.tsx b/components/AIMode/AIModeContext.tsx
index 4860b646a..4f78aacee 100644
--- a/components/AIMode/AIModeContext.tsx
+++ b/components/AIMode/AIModeContext.tsx
@@ -7,6 +7,7 @@ import {
   readWorkspaceTarget,
   sameTarget,
   workspaceHref,
+  type DocumentChat,
   type WorkspaceTarget,
 } from './workspaceUrl';
 
@@ -14,17 +15,15 @@ export interface AIModeContextValue {
   /** What the workspace is open on, as the URL says. */
   readonly target: WorkspaceTarget;
   selectTarget: (target: WorkspaceTarget) => void;
-  /** Select a conversation (null = the new-conversation screen). */
-  selectChat: (chatId: number | null) => void;
-  /** Open a document with a fresh chat beside it. */
-  selectDocument: (noteId: number) => void;
+  /** Open a document, on its most recent chat unless another is named. */
+  selectDocument: (noteId: number, chat?: DocumentChat) => void;
 }
 
 const AIModeContext = createContext<AIModeContextValue | null>(null);
 
 /**
  * Owns what the workspace page is open on. It lives in the URL, so a reload
- * or a shared link lands on the same conversation or document.
+ * or a shared link lands on the same document and chat.
  *
  * Mounted by the `/workspace` page, not globally: the doors elsewhere in the
  * app are plain links built with `workspaceHref`. Reads the URL with
@@ -42,23 +41,19 @@ export function AIModeProvider({ children }: { readonly children: ReactNode }) {
   const selectTarget = useCallback((next: WorkspaceTarget) => {
     if (sameTarget(next, targetRef.current)) return;
     // Replaced, not pushed: the workspace is one history entry however many
-    // conversations are opened in it, so Back leaves in a single step. Native
+    // documents and chats are opened in it, so Back leaves in a single step. Native
     // history with no state of our own, which the app router picks up and
     // feeds back through useSearchParams without fetching anything.
     window.history.replaceState(null, '', `${workspaceHref(next)}${window.location.hash}`);
   }, []);
-  const selectChat = useCallback(
-    (chatId: number | null) => selectTarget({ kind: 'conversation', chatId }),
-    [selectTarget]
-  );
   const selectDocument = useCallback(
-    (noteId: number) => selectTarget(documentTarget(noteId)),
+    (noteId: number, chat?: DocumentChat) => selectTarget(documentTarget(noteId, chat)),
     [selectTarget]
   );
 
   const value = useMemo<AIModeContextValue>(
-    () => ({ target, selectTarget, selectChat, selectDocument }),
-    [target, selectTarget, selectChat, selectDocument]
+    () => ({ target, selectTarget, selectDocument }),
+    [target, selectTarget, selectDocument]
   );
 
   return <AIModeContext.Provider value={value}>{children}</AIModeContext.Provider>;
diff --git a/components/AIMode/LegacyAIModeRedirect.tsx b/components/AIMode/LegacyAIModeRedirect.tsx
deleted file mode 100644
index c867ea22a..000000000
--- a/components/AIMode/LegacyAIModeRedirect.tsx
+++ /dev/null
@@ -1,22 +0,0 @@
-'use client';
-
-import { useEffect } from 'react';
-import { useRouter, useSearchParams } from 'next/navigation';
-import { legacyWorkspaceHref } from './workspaceUrl';
-
-/**
- * The workspace used to open over any page with `?ai=1`. A link from then
- * still lands on that page; this sends it on to the workspace page, open on
- * the same conversation or document. Reads the URL with `useSearchParams`,
- * so it needs a Suspense boundary above it.
- *
- * Temporary: delete once such links have aged out.
- */
-export function LegacyAIModeRedirect() {
-  const router = useRouter();
-  const href = legacyWorkspaceHref(useSearchParams());
-  useEffect(() => {
-    if (href) router.replace(href);
-  }, [href, router]);
-  return null;
-}
diff --git a/components/AIMode/WorkspacePage.tsx b/components/AIMode/WorkspacePage.tsx
index 582e5fc2c..961a0bdaa 100644
--- a/components/AIMode/WorkspacePage.tsx
+++ b/components/AIMode/WorkspacePage.tsx
@@ -1,23 +1,23 @@
 'use client';
 
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 import { PanelRightOpen } from 'lucide-react';
 import { PageLayout } from '@/app/layouts/PageLayout';
-import { cn } from '@/utils/styles';
+import { SidebarDocuments } from '@/app/layouts/components/SidebarDocuments';
+import { useFundingDocuments } from '@/contexts/FundingDocumentsContext';
 import { useMediaQuery } from '@/hooks/useMediaQuery';
 import { useResizableWidth } from '@/hooks/useResizableWidth';
+import { isActiveExecutionStatus } from '@/types/agentChat';
+import { isRfpNote } from '@/types/note';
+import { cn } from '@/utils/styles';
 import { AIModeProvider } from './AIModeContext';
 import { ChatPane } from './chat/ChatPane';
-import { DocumentCard } from './chat/DocumentCard';
-import { conversationTitleFor } from './chat/conversationTitle';
+import { newDraftTitle } from './copy';
 import { DocumentPane, type DocumentPaneView } from './document/DocumentPane';
 import { useAIModeDocument } from './document/useAIModeDocument';
 import { WorkspacePanes } from './shell/WorkspacePanes';
 import { WorkspaceTopBar } from './shell/WorkspaceTopBar';
-import { WorkspaceSidebar } from './sidebar/WorkspaceSidebar';
 import { useAIModeChat } from './useAIModeChat';
-import { newConversationTitle } from './copy';
-import { layoutFor } from './workspaceUrl';
 
 const CHAT_MIN_WIDTH = 360;
 const DOCUMENT_MIN_WIDTH = 420;
@@ -42,9 +42,9 @@ function useElementWidth(element: HTMLElement | null): number {
 }
 
 /**
- * The `/workspace` page: the app's shell with the user's conversations and
- * drafts in the left column where the nav items normally are, and the chat
- * and the document filling the rest. What it is open on lives in the URL.
+ * The `/workspace` page: the app's shell, with the chat and, beside it on
+ * the right, the document it is about. The user's documents are in the
+ * app's left sidebar, as on every page. What it is open on lives in the URL.
  */
 export function WorkspacePage() {
   return (
@@ -56,116 +56,92 @@ export function WorkspacePage() {
 
 function Workspace() {
   const state = useAIModeChat();
-  const { target } = state;
-  // A document opened from the sidebar comes first; a conversation's document sits beside it.
-  const layout = layoutFor(target);
+  const { target, note } = state;
 
-  // The lists sit in the app's left column from the width at which it stops
-  // being an icon rail (Tailwind's `sidebar-compact`). Below that they wait
-  // behind a button: a panel over the panes, or on a phone a screen of their own.
+  // The left column holds the user's documents from the width at which it
+  // stops being an icon rail (Tailwind's `sidebar-compact`). Below that they
+  // wait behind a button, in a panel over the panes: the top bar's, or on a
+  // phone (where the app has no left column at all) the chat header's.
   const listsInColumn = useMediaQuery('(min-width: 1240px)') === true;
   // Tailwind's `tablet` breakpoint; the side-by-side panes only exist from it up.
-  const isBelowTablet = useMediaQuery('(max-width: 767px)') === true;
-  const [listOpen, setListOpen] = useState(false);
-  const closeList = useCallback(() => setListOpen(false), []);
-  const toggleList = useCallback(() => setListOpen((open) => !open), []);
+  const phoneQuery = useMediaQuery('(max-width: 767px)');
+  const isBelowTablet = phoneQuery === true;
+  const [documentsOpen, setDocumentsOpen] = useState(false);
+  const closeDocuments = useCallback(() => setDocumentsOpen(false), []);
+  const toggleDocuments = useCallback(() => setDocumentsOpen((open) => !open), []);
   useEffect(() => {
-    if (listsInColumn) setListOpen(false);
+    if (listsInColumn) setDocumentsOpen(false);
   }, [listsInColumn]);
 
+  const latestExecution = state.chat.latestExecution;
+  const turnActive = latestExecution != null && isActiveExecutionStatus(latestExecution.status);
   const doc = useAIModeDocument({
-    note: state.note,
+    note,
     chat: state.chat.chat,
-    latestExecution: state.chat.latestExecution,
+    latestExecution,
+    assistantWorking: turnActive || state.anyTurnActive,
   });
 
-  // ---- pane widths: the side pane drags, the main pane takes the rest ----
+  // ---- the document's width: it drags, the chat takes the rest ----
   const [panesEl, setPanesEl] = useState<HTMLDivElement | null>(null);
   const panesWidth = useElementWidth(panesEl);
-  // Document or details in the phone's drawer; the column only shows the document.
-  const [documentView, setDocumentView] = useState<DocumentPaneView>('document');
-  // 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 ? DOCUMENT_MIN_WIDTH : CHAT_MIN_WIDTH;
-  const sideMaxWidth = Math.max(
-    sideMinWidth,
-    panesWidth - (sideIsDocument ? CHAT_MIN_WIDTH : DOCUMENT_MIN_WIDTH)
-  );
-  const sideWidth = useResizableWidth({
+  const documentMaxWidth = Math.max(DOCUMENT_MIN_WIDTH, panesWidth - CHAT_MIN_WIDTH);
+  const documentWidth = useResizableWidth({
     storageKey: 'ai-mode:document-width',
-    min: sideMinWidth,
-    max: sideMaxWidth,
+    min: DOCUMENT_MIN_WIDTH,
+    max: documentMaxWidth,
     defaultWidth: (width) => width * DOCUMENT_DEFAULT_SHARE,
     anchor: 'right',
   });
-  const isBelowTabletRef = useRef(isBelowTablet);
-  isBelowTabletRef.current = isBelowTablet;
+  // Document or details in the phone's drawer; the column only shows the document.
+  const [documentView, setDocumentView] = useState<DocumentPaneView>('document');
 
-  // On desktop the document pane opens by itself the moment a conversation
-  // gains a note, and a document that comes first shows at once everywhere.
-  // Otherwise on mobile the card in the transcript or the chat header is the
-  // way in, and it opens a drawer. Either way the user can close it and
-  // reopen it from there.
-  const noteId = state.note?.id ?? null;
-  const onDocument = target.kind === 'document';
-  const [documentOpen, setDocumentOpen] = useState(false);
+  // On desktop the document shows beside its chat as soon as it is open; on
+  // a phone the chat header's toggle opens it in a drawer. Either way the
+  // user can hide it and bring it back from there; that choice holds for
+  // the document it was made on. Until the width is known, nothing opens.
+  const noteId = note?.id ?? null;
+  const [documentChoice, setDocumentChoice] = useState<{
+    readonly noteId: number;
+    readonly open: boolean;
+  } | null>(null);
+  const documentOpen =
+    documentChoice != null && documentChoice.noteId === noteId
+      ? documentChoice.open
+      : phoneQuery === false;
+  const setDocumentOpen = useCallback(
+    (open: boolean) => {
+      if (noteId != null) setDocumentChoice({ noteId, open });
+    },
+    [noteId]
+  );
   useEffect(() => {
-    setDocumentOpen(noteId != null && (layout === 'document' || !isBelowTabletRef.current));
     setDocumentView('document');
-  }, [noteId, layout]);
+  }, [noteId]);
+  const closeDocument = useCallback(() => setDocumentOpen(false), [setDocumentOpen]);
+  const showDocument = noteId != null && documentOpen && !doc.missing;
 
-  const openDocument = useCallback(() => setDocumentOpen(true), []);
-  const closeDocument = useCallback(() => setDocumentOpen(false), []);
-  const showDocument = noteId != null && documentOpen;
-  // The Drafts list follows the open document's title as it is renamed.
-  const docTitle = doc.title;
-  const openNote = useMemo(
-    () => (noteId != null && docTitle ? { id: noteId, title: docTitle } : null),
-    [noteId, docTitle]
-  );
-  const documentTitle = doc.title || 'Document';
-  // The top bar names what is open: the conversation when the chat is the
-  // main pane, the document when it is, and the new-conversation screen by
-  // what it is for — an RFP or a proposal.
-  const { title: conversationTitle } = conversationTitleFor(state);
-  const headerTitle =
-    layout === 'document'
-      ? documentTitle
-      : target.chatId != null
-        ? conversationTitle
-        : newConversationTitle(state.intent);
+  // The sidebar's row follows the open document: a rename in the masthead,
+  // a name the assistant gave it, the latest edit.
+  const { patch } = useFundingDocuments();
+  const { title: docTitle, updatedDate: docUpdatedDate } = doc;
+  useEffect(() => {
+    if (noteId == null || !docTitle) return;
+    patch(
+      noteId,
+      docUpdatedDate ? { title: docTitle, updatedDate: docUpdatedDate } : { title: docTitle }
+    );
+  }, [noteId, docTitle, docUpdatedDate, patch]);
 
-  // The turn that created the document, for seating its card in the transcript.
-  const documentCardExecutionId = useMemo(() => {
-    if (noteId == null) return null;
-    for (const execution of state.chat.chat?.executions ?? []) {
-      const created = (execution.activity ?? []).some(
-        (item) =>
-          item.type === 'tool_call' &&
-          item.tool === 'create_note' &&
-          item.status === 'succeeded' &&
-          item.note_id === noteId
-      );
-      if (created) return execution.id;
-    }
-    return null;
-  }, [noteId, state.chat.chat]);
-  // A document opened from the sidebar is the main pane; no card needed.
-  const documentCard =
-    noteId != null && !onDocument ? (
-      <DocumentCard
-        title={documentTitle}
-        status={doc.status}
-        open={showDocument}
-        onOpen={openDocument}
-      />
-    ) : null;
+  // The top bar names what is open: the document, or on the start screen
+  // what it will produce — an RFP or a proposal.
+  const headerTitle = target.kind === 'new' ? newDraftTitle(state.intent) : doc.title || 'Untitled';
 
   const documentPane = (presentation: 'pane' | 'drawer') => (
     <DocumentPane
       document={doc}
       chat={state.chat.chat}
+      assistantWorking={state.anyTurnActive}
       view={documentView}
       onViewChange={setDocumentView}
       presentation={presentation}
@@ -175,53 +151,40 @@ function Workspace() {
   );
 
   return (
-    <PageLayout
-      fullBleed
-      leftSidebarContent={
-        listsInColumn ? (
-          <div className="workspace-fade-in h-full">
-            <WorkspaceSidebar state={state} openNote={openNote} />
-          </div>
-        ) : null
-      }
-    >
+    <PageLayout fullBleed>
       <div ref={setPanesEl} className="workspace-fade-in flex min-h-0 flex-1 flex-col bg-gray-50">
         <WorkspaceTopBar
           title={headerTitle}
-          listOpen={listOpen}
-          onToggleList={listsInColumn || isBelowTablet ? undefined : toggleList}
+          listOpen={documentsOpen}
+          onToggleList={listsInColumn || isBelowTablet ? undefined : toggleDocuments}
         />
 
         <WorkspacePanes
-          layout={layout}
           isBelowTablet={isBelowTablet}
-          sideWidth={{ ...sideWidth, min: sideMinWidth, max: sideMaxWidth }}
-          lists={
-            listsInColumn ? null : (
-              <WorkspaceSidebar state={state} openNote={openNote} onNavigate={closeList} />
-            )
+          documentWidth={{ ...documentWidth, min: DOCUMENT_MIN_WIDTH, max: documentMaxWidth }}
+          documents={
+            listsInColumn ? null : <SidebarDocuments divider={false} onNavigate={closeDocuments} />
           }
-          listOpen={listOpen}
-          onCloseList={closeList}
+          documentsOpen={documentsOpen}
+          onCloseDocuments={closeDocuments}
           onCloseDocumentDrawer={closeDocument}
           chat={
             <ChatPane
               state={state}
-              // The top bar names the chat when it is the main pane.
-              showTitle={layout !== 'chat'}
-              onOpenConversations={() => setListOpen(true)}
-              documentCard={documentCard}
-              documentCardExecutionId={documentCardExecutionId}
+              documentIsRfp={isRfpNote(doc.content)}
+              documentIsEmpty={doc.status === 'empty'}
+              documentMissing={doc.missing}
+              onOpenDocuments={isBelowTablet ? () => setDocumentsOpen(true) : undefined}
               headerActions={
                 noteId != null && (
                   <button
                     type="button"
-                    onClick={() => setDocumentOpen((open) => !open)}
+                    onClick={() => setDocumentOpen(!showDocument)}
                     aria-pressed={showDocument}
                     aria-label={showDocument ? 'Hide document' : 'Show document'}
                     title={showDocument ? 'Hide document' : 'Show document'}
                     className={cn(
-                      'inline-flex shrink-0 items-center justify-center rounded-lg p-1.5 transition-colors',
+                      'flex h-[30px] w-[30px] shrink-0 items-center justify-center rounded-lg transition-colors',
                       showDocument
                         ? 'bg-primary-50 text-primary-700 hover:bg-primary-100'
                         : 'text-gray-500 hover:bg-gray-100 hover:text-gray-900'
diff --git a/components/AIMode/chat/ChatMenu.tsx b/components/AIMode/chat/ChatMenu.tsx
new file mode 100644
index 000000000..6fc668f27
--- /dev/null
+++ b/components/AIMode/chat/ChatMenu.tsx
@@ -0,0 +1,85 @@
+'use client';
+
+import { useState } from 'react';
+import { MoreHorizontal, Pencil, Trash2 } from 'lucide-react';
+import { BaseMenu, BaseMenuItem } from '@/components/ui/form/BaseMenu';
+import { BaseModal } from '@/components/ui/BaseModal';
+import { Button } from '@/components/ui/Button';
+import { cn } from '@/utils/styles';
+
+interface ChatMenuProps {
+  readonly title: string;
+  readonly onRename: () => void;
+  /** Called only after the user confirms. */
+  readonly onDelete: () => void;
+  readonly className?: string;
+}
+
+/**
+ * The open chat's ellipsis menu: rename inline, or delete behind a
+ * confirmation. Deleting a chat never touches its document.
+ */
+export function ChatMenu({ title, onRename, onDelete, className }: ChatMenuProps) {
+  const [confirming, setConfirming] = useState(false);
+
+  return (
+    <>
+      <BaseMenu
+        align="end"
+        trigger={
+          <button
+            type="button"
+            aria-label="Chat options"
+            title="Chat options"
+            className={cn(
+              'flex h-[30px] w-[30px] items-center justify-center rounded-lg text-gray-500 transition-colors hover:bg-gray-100 hover:text-gray-900',
+              className
+            )}
+          >
+            <MoreHorizontal className="h-4 w-4" />
+          </button>
+        }
+      >
+        <BaseMenuItem onSelect={onRename} className="gap-2 text-gray-700">
+          <Pencil className="h-3.5 w-3.5" aria-hidden="true" />
+          Rename
+        </BaseMenuItem>
+        <BaseMenuItem
+          onSelect={() => setConfirming(true)}
+          className="gap-2 text-red-600 focus:bg-red-50 focus:text-red-700"
+        >
+          <Trash2 className="h-3.5 w-3.5" aria-hidden="true" />
+          Delete
+        </BaseMenuItem>
+      </BaseMenu>
+
+      <BaseModal
+        isOpen={confirming}
+        onClose={() => setConfirming(false)}
+        title="Delete chat?"
+        size="sm"
+        footer={
+          <div className="flex justify-end gap-2">
+            <Button variant="outlined" size="sm" onClick={() => setConfirming(false)}>
+              Cancel
+            </Button>
+            <Button
+              size="sm"
+              className="bg-red-600 text-white hover:bg-red-700"
+              onClick={() => {
+                setConfirming(false);
+                onDelete();
+              }}
+            >
+              Delete
+            </Button>
+          </div>
+        }
+      >
+        <p className="text-sm text-gray-600">
+          “{title}” and its messages will be deleted. The document stays as it is.
+        </p>
+      </BaseModal>
+    </>
+  );
+}
diff --git a/components/AIMode/chat/ChatPane.tsx b/components/AIMode/chat/ChatPane.tsx
index 736857486..e2b80b7f6 100644
--- a/components/AIMode/chat/ChatPane.tsx
+++ b/components/AIMode/chat/ChatPane.tsx
@@ -1,15 +1,15 @@
 'use client';
 
-import { useEffect, useRef, useState, type ReactNode } from 'react';
-import { PanelLeftOpen } from 'lucide-react';
+import { useCallback, useEffect, useRef, useState, type ReactNode } from 'react';
+import Link from 'next/link';
+import { History, PanelLeftOpen } from 'lucide-react';
 import { ChatComposer } from '@/components/AgentChat/ChatComposer';
+import { ChatEmptyState } from '@/components/AgentChat/ChatEmptyState';
+import { ChatPicker } from '@/components/AgentChat/ChatPicker';
 import { ChatTranscript } from '@/components/AgentChat/ChatTranscript';
 import { JumpToLatestButton } from '@/components/AgentChat/JumpToLatestButton';
 import { ModelControls } from '@/components/AgentChat/ModelControls';
 import { useJumpToLatest } from '@/hooks/useJumpToLatest';
-import { ConversationMenu } from '../sidebar/ConversationMenu';
-import { ConversationTitleField } from './ConversationTitleField';
-import { conversationTitleFor } from './conversationTitle';
 import { Button } from '@/components/ui/Button';
 import { ChatTranscriptSkeleton } from '@/components/skeletons/AIModeSkeleton';
 import { cn } from '@/utils/styles';
@@ -23,43 +23,52 @@ import {
   startComposerSendClass,
 } from '../start/startComposer';
 import { StartScreen } from '../start/StartScreen';
-import { DocumentChatEmptyState } from './DocumentChatEmptyState';
+import { ChatMenu } from './ChatMenu';
+import { ChatTitleField } from './ChatTitleField';
 
 interface ChatPaneProps {
   readonly state: AIModeChatState;
-  /**
-   * Whether the pane's header names the chat. Not when the chat is the main
-   * pane: the app's top bar already names it there, at every width.
-   */
-  readonly showTitle: boolean;
-  /** Header controls seated right of the title — the document toggle. */
+  /** Header controls at its right end: the document toggle. */
   readonly headerActions?: ReactNode;
-  /** Below the tablet breakpoint the list is a drawer; this opens it. */
-  readonly onOpenConversations?: () => void;
-  /**
-   * The document's card, and the turn it belongs under. With no matching
-   * turn (activity not loaded for it) the card trails the transcript instead.
-   */
-  readonly documentCard?: ReactNode;
-  readonly documentCardExecutionId?: number | null;
+  /** What the open document is, for a new chat's suggestions. */
+  readonly documentIsRfp: boolean;
+  /** Nothing is written in the open document yet, for a new chat's suggestions. */
+  readonly documentIsEmpty: boolean;
+  /** The open document no longer exists. */
+  readonly documentMissing: boolean;
+  /** On a phone, which has no left column, this opens the user's documents. */
+  readonly onOpenDocuments?: () => void;
 }
 
-/** The middle pane: transcript, live progress, and the composer. */
+/**
+ * The chat: on a document, its header (the chat's title, History, its menu
+ * and the document toggle), the transcript and the composer; on the screen
+ * that starts a new draft, the composer in the middle of the page.
+ */
 export function ChatPane({
   state,
-  showTitle,
   headerActions,
-  onOpenConversations,
-  documentCard,
-  documentCardExecutionId,
+  documentIsRfp,
+  documentIsEmpty,
+  documentMissing,
+  onOpenDocuments,
 }: ChatPaneProps) {
-  const { chatId, list, chat, modelSelection, draft, setDraft, notice, composerBusy, canStop } =
-    state;
+  const {
+    chatId,
+    list,
+    listReady,
+    chat,
+    modelSelection,
+    draft,
+    setDraft,
+    notice,
+    composerBusy,
+    canStop,
+  } = state;
   const composerRef = useRef<HTMLTextAreaElement>(null);
   const paneRef = useRef<HTMLDivElement>(null);
-  const onDocument = state.target.kind === 'document';
-  // The new-conversation screen: white, untitled, the composer in the middle.
-  const onStart = chatId == null && !onDocument;
+  const onStart = state.target.kind === 'new';
+  const resolving = state.resolvingChat;
 
   // ---- transcript auto-scroll ----
   // Follows new content while the reader is at the bottom; never yanks the
@@ -88,19 +97,46 @@ export function ChatPane({
     setRenaming(false);
   }, [chatId]);
 
-  // The new-conversation screen is there to be typed into: the caret is in
-  // the box the moment it opens, whichever door it opened from.
+  // The start screen is there to be typed into: the caret is in the box the
+  // moment it opens, whichever door it opened from.
   useEffect(() => {
     if (onStart) composerRef.current?.focus();
-  }, [onStart, chatId]);
+  }, [onStart]);
 
-  const listBlocked = list.access === 'hidden';
+  /**
+   * A suggestion loads the composer rather than sending: its message is a
+   * starting point the user finishes. Focus follows the text so the caret is
+   * already waiting at the end of it.
+   */
+  const { clearNotice } = state;
+  const applyPreset = useCallback(
+    (message: string) => {
+      clearNotice();
+      setDraft(message);
+      const textarea = composerRef.current;
+      if (!textarea) return;
+      textarea.focus();
+      textarea.setSelectionRange(message.length, message.length);
+    },
+    [clearNotice, setDraft]
+  );
+
+  const aiBlocked = state.researchAI.budget?.tier === 'blocked';
+  const listBlocked = listReady && list.access === 'hidden';
+  const listFailed = listReady && list.access === 'error';
   const chatUnavailable =
     chatId != null && (chat.access === 'not_found' || chat.access === 'unauthorized');
   const composerDisabled =
-    listBlocked || chatUnavailable || (chatId != null && chat.access === 'loading');
+    aiBlocked ||
+    documentMissing ||
+    listBlocked ||
+    resolving ||
+    chatUnavailable ||
+    (chatId != null && chat.access === 'loading');
 
-  const { currentTitle, title, loading: titleLoading } = conversationTitleFor(state);
+  const title = chatId == null ? 'New chat' : state.chatTitle?.trim() || 'Untitled chat';
+  const titleLoading =
+    resolving || (chatId != null && state.chatTitle == null && chat.chat == null);
 
   const modelControls = (
     <ModelControls
@@ -122,7 +158,8 @@ export function ChatPane({
       textareaRef={composerRef}
       value={draft}
       onChange={setDraft}
-      onSend={state.send}
+      // Not the handler itself: the button would hand it its click event as the text.
+      onSend={() => void state.send()}
       onStop={state.stop}
       busy={composerBusy}
       canStop={canStop}
@@ -150,102 +187,151 @@ export function ChatPane({
     />
   );
 
+  const body = (): ReactNode => {
+    if (aiBlocked) return <AccessBlocked detail={null} />;
+    if (onStart) {
+      return <StartScreen composer={composer} greeting={AI_MODE_GREETING} intent={state.intent} />;
+    }
+    if (documentMissing) {
+      return (
+        <div className="flex flex-col items-center gap-3 py-16 text-center">
+          <p className="text-sm text-gray-600">This document is no longer available.</p>
+          <Link
+            href="/my-funding"
+            className="text-sm font-medium text-primary-600 hover:text-primary-700"
+          >
+            Go to My Funding
+          </Link>
+        </div>
+      );
+    }
+    if (listBlocked) return <AccessBlocked detail={list.accessDetail} />;
+    if (resolving) {
+      // Never the new-chat state while the most recent chat is being found:
+      // it would read as the chat having gone.
+      return listFailed ? (
+        <RetryState message="Couldn’t load this document’s chats." onRetry={list.refresh} />
+      ) : (
+        <ChatTranscriptSkeleton />
+      );
+    }
+    const emptyState = (
+      <div className="flex min-h-[50vh] flex-col justify-center">
+        <ChatEmptyState
+          noteIsEmpty={documentIsEmpty}
+          noteIsRfp={documentIsRfp}
+          onSelectPreset={applyPreset}
+          presetsDisabled={composerDisabled}
+          noun="document"
+        />
+      </div>
+    );
+    if (chatId == null) return emptyState;
+    switch (chat.access) {
+      case 'unauthorized':
+        return <AccessBlocked detail={null} />;
+      case 'error':
+        if (chat.chat == null) {
+          return <RetryState message="Couldn’t load this chat." onRetry={chat.refetch} />;
+        }
+        break;
+      case 'loading':
+      case 'not_found':
+        // A chat that is gone hands over to the document's most recent one.
+        if (chat.chat == null) return <ChatTranscriptSkeleton />;
+        break;
+    }
+    if (!chat.chat) return null;
+    const isEmpty =
+      chat.chat.messages.length === 0 && chat.chat.executions.length === 0 && !chat.pendingSend;
+    if (isEmpty) return emptyState;
+    return (
+      <div className="animate-in fade-in duration-300">
+        <ChatTranscript chat={chat.chat} pendingSend={chat.pendingSend} />
+      </div>
+    );
+  };
+
   return (
     <div ref={paneRef} className={cn('flex h-full min-h-0 flex-col', onStart && 'bg-white')}>
-      {/* No border or fill: the title and its controls float over the pane. */}
-      <header className="flex h-12 shrink-0 items-center gap-2 px-3">
-        {onOpenConversations && (
-          <button
-            type="button"
-            onClick={onOpenConversations}
-            aria-label="Show conversations and documents"
-            className="rounded-lg p-1.5 text-gray-500 transition-colors hover:bg-gray-100 hover:text-gray-900 tablet:!hidden"
-          >
-            <PanelLeftOpen className="h-4 w-4" />
-          </button>
-        )}
-        {renaming && chatId != null ? (
-          <ConversationTitleField
-            initialValue={currentTitle ?? ''}
-            className="max-w-md flex-1"
-            onCancel={() => setRenaming(false)}
-            onCommit={(value) => {
-              setRenaming(false);
-              const next = value.trim();
-              if (next && next !== (currentTitle ?? '')) state.rename(chatId, next);
-            }}
-          />
-        ) : !showTitle ? (
-          // The top bar names it; the header carries only the controls.
-          <span className="flex-1" />
-        ) : titleLoading ? (
-          <div className="flex min-w-0 flex-1 items-center" aria-busy="true">
-            <div className="h-3.5 w-56 max-w-full animate-pulse rounded bg-gray-100" />
-          </div>
-        ) : (
-          <h1 className="min-w-0 flex-1 truncate text-sm font-medium text-gray-800">{title}</h1>
-        )}
-        {chatId != null && !renaming && (
-          <ConversationMenu
-            title={title}
-            onRename={() => setRenaming(true)}
-            onDelete={(options) => state.deleteChat(chatId, options)}
-            loadNotes={() => state.notesForChat(chatId)}
-          />
-        )}
-        {headerActions}
-      </header>
+      {/* No border or fill: the title and its controls float over the pane.
+          The start screen has no chat yet, so no header. */}
+      {!onStart && !documentMissing && (
+        <header
+          className={cn(
+            'flex h-12 shrink-0 items-center gap-1 pr-2.5',
+            onOpenDocuments ? 'pl-2' : 'pl-5'
+          )}
+        >
+          {onOpenDocuments && (
+            <button
+              type="button"
+              onClick={onOpenDocuments}
+              aria-label="Show documents"
+              title="Show documents"
+              className="mr-1 flex h-[30px] w-[30px] shrink-0 items-center justify-center rounded-lg text-gray-500 transition-colors hover:bg-gray-100 hover:text-gray-900"
+            >
+              <PanelLeftOpen className="h-4 w-4" aria-hidden="true" />
+            </button>
+          )}
+          {renaming && chatId != null ? (
+            <ChatTitleField
+              initialValue={state.chatTitle ?? ''}
+              className="max-w-md flex-1"
+              onCancel={() => setRenaming(false)}
+              onCommit={(value) => {
+                setRenaming(false);
+                const next = value.trim();
+                if (next && next !== (state.chatTitle ?? '')) void state.rename(next);
+              }}
+            />
+          ) : titleLoading ? (
+            <div className="flex min-w-0 flex-1 items-center" aria-busy="true">
+              <div className="h-3.5 w-48 max-w-full animate-pulse rounded bg-gray-100" />
+            </div>
+          ) : (
+            <h2 className="min-w-0 flex-1 truncate text-[13px] font-medium text-gray-700">
+              {title}
+            </h2>
+          )}
+
+          {!listBlocked && (
+            <ChatPicker
+              chats={listReady ? list.chats : []}
+              activeChatId={chatId}
+              activeTitle={state.chatTitle}
+              onSelect={(id) => state.openChat(id)}
+              onOpen={() => void list.refresh()}
+              onNewChat={() => state.openChat('new')}
+              failed={listFailed}
+              className="flex-none"
+              trigger={
+                <button
+                  type="button"
+                  aria-label="Chat history"
+                  title="Chat history"
+                  className="flex h-[30px] w-[30px] items-center justify-center rounded-lg text-gray-500 transition-colors hover:bg-gray-100 hover:text-gray-900 data-[state=open]:bg-gray-100 data-[state=open]:text-gray-900"
+                >
+                  <History className="h-4 w-4" aria-hidden="true" />
+                </button>
+              }
+            />
+          )}
+          {chatId != null && !renaming && (
+            <ChatMenu
+              title={title}
+              onRename={() => setRenaming(true)}
+              onDelete={() => void state.deleteChat(chatId)}
+            />
+          )}
+          {headerActions}
+        </header>
+      )}
 
       <div className="relative min-h-0 flex-1">
         <div ref={scrollRef} onScroll={handleScroll} className="h-full overflow-y-auto">
-          <div
-            ref={contentRef}
-            className={cn(
-              'mx-auto w-full px-4 py-5 tablet:!px-6',
-              // The start screen seats the journey rail beside the composer.
-              onStart ? 'max-w-[1100px]' : 'max-w-[760px]'
-            )}
-          >
-            {listBlocked ? (
-              <AccessBlocked detail={list.accessDetail} />
-            ) : chatId == null && onDocument ? (
-              <DocumentChatEmptyState />
-            ) : chatId == null ? (
-              <StartScreen composer={composer} greeting={AI_MODE_GREETING} intent={state.intent} />
-            ) : chat.access === 'loading' && chat.chat == null ? (
-              <ChatTranscriptSkeleton />
-            ) : chat.access === 'not_found' ? (
-              <p className="py-16 text-center text-sm text-gray-600">
-                This conversation is no longer available.
-              </p>
-            ) : chat.access === 'unauthorized' ? (
-              <AccessBlocked detail={null} />
-            ) : chat.access === 'error' && chat.chat == null ? (
-              <div className="flex flex-col items-center gap-3 py-16 text-center">
-                <p className="text-sm text-gray-600">Couldn’t load this conversation.</p>
-                <Button variant="outlined" size="sm" onClick={chat.refetch}>
-                  Try again
-                </Button>
-              </div>
-            ) : chat.chat ? (
-              <div className="animate-in fade-in duration-300">
-                <ChatTranscript
-                  chat={chat.chat}
-                  pendingSend={chat.pendingSend}
-                  renderExecutionExtra={
-                    documentCard && documentCardExecutionId != null
-                      ? (execution) =>
-                          execution.id === documentCardExecutionId ? (
-                            <div className="pt-1">{documentCard}</div>
-                          ) : null
-                      : undefined
-                  }
-                />
-                {documentCard && documentCardExecutionId == null && (
-                  <div className="mt-5">{documentCard}</div>
-                )}
-              </div>
-            ) : null}
+          <div ref={contentRef} className="mx-auto w-full max-w-[760px] px-4 py-5 tablet:!px-6">
+            {body()}
           </div>
         </div>
         <div className="pointer-events-none absolute inset-x-0 bottom-3 flex justify-center">
@@ -257,20 +343,34 @@ export function ChatPane({
         </div>
       </div>
 
-      {/* 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. */}
-      {(chatId != null || onDocument) && (
+      {/* A document's chat keeps the composer docked at the bottom; the start
+          screen seats it in the middle. */}
+      {!onStart && !documentMissing && (
         <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}
-          </div>
+          <div className="mx-auto w-full max-w-[760px] px-3 py-3 tablet:!px-5">{composer}</div>
         </div>
       )}
     </div>
   );
 }
 
+function RetryState({
+  message,
+  onRetry,
+}: {
+  readonly message: string;
+  readonly onRetry: () => void;
+}) {
+  return (
+    <div className="flex flex-col items-center gap-3 py-16 text-center">
+      <p className="text-sm text-gray-600">{message}</p>
+      <Button variant="outlined" size="sm" onClick={onRetry}>
+        Try again
+      </Button>
+    </div>
+  );
+}
+
 function AccessBlocked({ detail }: { readonly detail: string | null }) {
   return (
     <div className="flex flex-col items-center gap-2 py-16 text-center">
diff --git a/components/AIMode/chat/ConversationTitleField.tsx b/components/AIMode/chat/ChatTitleField.tsx
similarity index 80%
rename from components/AIMode/chat/ConversationTitleField.tsx
rename to components/AIMode/chat/ChatTitleField.tsx
index b214b9bb4..511cd79dd 100644
--- a/components/AIMode/chat/ConversationTitleField.tsx
+++ b/components/AIMode/chat/ChatTitleField.tsx
@@ -4,7 +4,7 @@ import { useEffect, useRef, useState, type KeyboardEvent } from 'react';
 import { MAX_CHAT_TITLE_LENGTH } from '@/types/agentChat';
 import { cn } from '@/utils/styles';
 
-interface ConversationTitleFieldProps {
+interface ChatTitleFieldProps {
   readonly initialValue: string;
   readonly onCommit: (value: string) => void;
   readonly onCancel: () => void;
@@ -12,16 +12,16 @@ interface ConversationTitleFieldProps {
 }
 
 /**
- * Inline title editor: Enter or blur commits, Escape cancels. Escape is
- * claimed here so nothing around the field — the lists' panel, a menu — also
- * acts on it.
+ * Inline title editor for a chat: Enter or blur commits, Escape cancels.
+ * Escape is claimed here so nothing around the field — an overlay, a menu —
+ * also acts on it.
  */
-export function ConversationTitleField({
+export function ChatTitleField({
   initialValue,
   onCommit,
   onCancel,
   className,
-}: ConversationTitleFieldProps) {
+}: ChatTitleFieldProps) {
   const [value, setValue] = useState(initialValue);
   const inputRef = useRef<HTMLInputElement>(null);
   useEffect(() => {
@@ -48,7 +48,7 @@ export function ConversationTitleField({
       onKeyDown={handleKeyDown}
       onBlur={() => onCommit(value)}
       maxLength={MAX_CHAT_TITLE_LENGTH}
-      aria-label="Conversation title"
+      aria-label="Chat title"
       className={cn(
         'w-full min-w-0 rounded-md border border-primary-300 bg-white px-2 py-1 text-sm text-gray-900 outline-none ring-2 ring-primary-100',
         className
diff --git a/components/AIMode/chat/DocumentCard.tsx b/components/AIMode/chat/DocumentCard.tsx
deleted file mode 100644
index e8511b6a9..000000000
--- a/components/AIMode/chat/DocumentCard.tsx
+++ /dev/null
@@ -1,72 +0,0 @@
-'use client';
-
-import { FileText, Lock } from 'lucide-react';
-import { Loader } from '@/components/ui/Loader';
-import { cn } from '@/utils/styles';
-import type { DocumentStatus } from '../document/useAIModeDocument';
-
-interface DocumentCardProps {
-  readonly title: string;
-  readonly status: DocumentStatus;
-  /** The document is showing beside the chat (desktop) or in the drawer (mobile). */
-  readonly open: boolean;
-  readonly onOpen: () => void;
-}
-
-/**
- * The document's card in the transcript, seated under the turn that created
- * it. The one place the reader is told the document exists and can reach it
- * from — the pane beside the chat on desktop, a drawer on mobile.
- */
-export function DocumentCard({ title, status, open, onOpen }: DocumentCardProps) {
-  const writing = status === 'drafting' || status === 'working';
-  const subtitle = writing
-    ? status === 'drafting'
-      ? 'Writing…'
-      : 'Working…'
-    : status === 'empty'
-      ? 'Nothing written yet'
-      : 'Ready to edit';
-
-  return (
-    <button
-      type="button"
-      onClick={onOpen}
-      aria-pressed={open}
-      className={cn(
-        'flex w-full items-center gap-3 rounded-xl border bg-white p-3 text-left shadow-sm transition-colors',
-        open
-          ? 'border-primary-200 ring-1 ring-primary-100'
-          : 'border-gray-200 hover:border-primary-200 hover:bg-primary-50/40'
-      )}
-    >
-      <span
-        className={cn(
-          'flex h-12 w-10 shrink-0 items-center justify-center rounded-md border bg-gray-50',
-          writing ? 'border-primary-200 text-primary-600' : 'border-gray-200 text-gray-500'
-        )}
-        aria-hidden="true"
-      >
-        {writing ? (
-          <Loader size="sm" className="!h-4 !w-4 text-primary-500" />
-        ) : (
-          <FileText className="h-5 w-5" />
-        )}
-      </span>
-      <span className="min-w-0 flex-1">
-        <span className="block truncate text-sm font-medium text-gray-900">{title}</span>
-        <span className="mt-0.5 flex items-center gap-1 text-xs text-gray-500">
-          <span>Document</span>
-          <span aria-hidden="true">·</span>
-          <Lock className="h-3 w-3" aria-hidden="true" />
-          <span>Only you</span>
-          <span aria-hidden="true">·</span>
-          <span className={cn(writing && 'text-primary-600')}>{subtitle}</span>
-        </span>
-      </span>
-      <span className="shrink-0 rounded-lg border border-gray-200 px-3 py-1.5 text-sm font-medium text-gray-800">
-        {open ? 'Showing' : 'Open'}
-      </span>
-    </button>
-  );
-}
diff --git a/components/AIMode/chat/DocumentChatEmptyState.tsx b/components/AIMode/chat/DocumentChatEmptyState.tsx
deleted file mode 100644
index 8d42eb01d..000000000
--- a/components/AIMode/chat/DocumentChatEmptyState.tsx
+++ /dev/null
@@ -1,16 +0,0 @@
-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>
-    </div>
-  );
-}
diff --git a/components/AIMode/chat/conversationTitle.ts b/components/AIMode/chat/conversationTitle.ts
deleted file mode 100644
index 23f555a9d..000000000
--- a/components/AIMode/chat/conversationTitle.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { newConversationTitle } from '../copy';
-import type { AIModeChatState } from '../useAIModeChat';
-
-export interface ConversationTitle {
-  /** The title as stored, with no fallback; null on a new conversation or while still unknown. */
-  readonly currentTitle: string | null;
-  /** What the panes show: the title, or a placeholder for a new or untitled conversation. */
-  readonly title: string;
-  /** A conversation is open but neither the listing nor the chat itself has named it yet. */
-  readonly loading: boolean;
-}
-
-/**
- * The open conversation's title. The listing usually knows it before the
- * chat itself has loaded, so a refresh doesn't flash "Untitled" while the
- * transcript is fetched.
- */
-export function conversationTitleFor(state: AIModeChatState): ConversationTitle {
-  const { chatId, list, chat, target } = state;
-  const listedTitle =
-    chatId == null ? null : (list.chats.find((item) => item.id === chatId)?.title ?? null);
-  const currentTitle =
-    chatId == null ? null : state.titleFor(chatId, chat.chat?.title ?? listedTitle);
-  const loading =
-    chatId != null && currentTitle == null && (chat.chat == null || list.access === 'loading');
-  const title =
-    chatId == null
-      ? target.kind === 'document'
-        ? 'New chat'
-        : newConversationTitle(state.intent)
-      : (currentTitle?.trim() ?? '') || 'Untitled conversation';
-  return { currentTitle, title, loading };
-}
diff --git a/components/AIMode/copy.ts b/components/AIMode/copy.ts
index 673ae8bb0..efd7b0ffe 100644
--- a/components/AIMode/copy.ts
+++ b/components/AIMode/copy.ts
@@ -1,19 +1,23 @@
 import type { FundingIntent } from '@/components/Funding/fundingDirection';
 
 /**
- * User-facing copy for AI Mode, in one place so the product name and the
- * new-conversation wording can change without touching components.
+ * User-facing copy for the workspace, in one place so the product name and
+ * the new-draft wording can change without touching components.
  */
 export const AI_MODE_NAME = 'Workspace';
 
 /**
- * What the new-conversation screen is called, in the app's top bar: named
- * for what it will produce, not for the chat.
+ * What the new-draft screen is called, in the app's top bar: named for what
+ * it will produce, not for the chat.
  */
-export const newConversationTitle = (intent: FundingIntent): string =>
+export const newDraftTitle = (intent: FundingIntent): string =>
   intent === 'fund' ? 'New RFP' : 'New proposal';
 
-/** The heading of the new-conversation screen. */
+/** A new draft's title until the assistant (or the user) names it. */
+export const untitledDraftTitle = (intent: FundingIntent): string =>
+  intent === 'fund' ? 'Untitled RFP' : 'Untitled proposal';
+
+/** The heading of the new-draft screen. */
 export const AI_MODE_GREETING = 'Let’s get started';
 
 /** The line under the greeting and what the composer asks for, per side of the money. */
diff --git a/components/AIMode/document/DocumentPane.tsx b/components/AIMode/document/DocumentPane.tsx
index 9f10735a3..722ace455 100644
--- a/components/AIMode/document/DocumentPane.tsx
+++ b/components/AIMode/document/DocumentPane.tsx
@@ -4,6 +4,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import type { Editor } from '@tiptap/react';
 import { BlockEditorClientWrapper } from '@/components/Editor/components/BlockEditor/components/BlockEditorClientWrapper';
 import { setDocumentTitle } from '@/components/Editor/lib/utils/documentTitle';
+import { AssistantActivityDot } from '@/components/AgentChat/AssistantActivityDot';
 import { NoteReviewBanner } from '@/components/Notebook/NoteReview/NoteReviewBanner';
 import {
   PublishingForm,
@@ -40,6 +41,8 @@ interface DocumentPaneProps {
   readonly document: AIModeDocument;
   /** The open chat, whose activity is one of the review's version signals. */
   readonly chat: AgentChat | null;
+  /** The assistant has a turn running on this document in one of its other chats. */
+  readonly assistantWorking?: boolean;
   /** Which of the drawer's two views is showing; the column only has the document. */
   readonly view: DocumentPaneView;
   readonly onViewChange: (view: DocumentPaneView) => void;
@@ -68,6 +71,7 @@ interface DocumentPaneProps {
 export function DocumentPane({
   document,
   chat,
+  assistantWorking = false,
   view,
   onViewChange,
   presentation = 'pane',
@@ -236,8 +240,19 @@ export function DocumentPane({
       <PublishingFormProvider
         publishTitle={title}
         publishConfirmation={isPane ? <PublishDialog title={title} onRename={rename} /> : undefined}
+        refreshedNote={document.details}
       >
         <div className={cn('relative flex h-full min-h-0 flex-col bg-white', className)}>
+          {/* Above the content, so it does not scroll: flashing while the
+              assistant works on the document, still while its changes wait
+              to be accepted or rejected. The drawer's top row has no room;
+              the chat beside it shows the work there. */}
+          {isPane && (writing || assistantWorking || reviewing) && (
+            <AssistantActivityDot
+              state={writing || assistantWorking ? 'working' : 'review'}
+              className="absolute right-4 top-4 z-10"
+            />
+          )}
           {!isPane && (
             <DrawerStrip view={view} onViewChange={onViewChange} onOpenDetails={openDetails} />
           )}
diff --git a/components/AIMode/document/useAIModeDocument.ts b/components/AIMode/document/useAIModeDocument.ts
index bdc2c0d25..9a6f9d02a 100644
--- a/components/AIMode/document/useAIModeDocument.ts
+++ b/components/AIMode/document/useAIModeDocument.ts
@@ -2,7 +2,7 @@
 
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import type { JSONContent } from '@tiptap/core';
-import { NoteService } from '@/services/note.service';
+import { NoteError, NoteService } from '@/services/note.service';
 import type { NoteWithContent } from '@/types/note';
 import {
   isActiveExecutionStatus,
@@ -13,7 +13,7 @@ import {
 } from '@/types/agentChat';
 
 export type DocumentStatus =
-  /** No note on this conversation: the pane has nothing to show. */
+  /** No document is open: the pane has nothing to show. */
   | 'absent'
   /** The note exists but the agent hasn't written a version yet. */
   | 'empty'
@@ -39,8 +39,17 @@ export interface AIModeDocument {
   readonly title: string;
   /** Shows a new title at once. Saving it is the caller's, through the note's details writer. */
   readonly rename: (title: string) => void;
+  /** When the note was last changed, as far as this pane knows. */
+  readonly updatedDate: string | null;
+  /**
+   * The note as fetched again after the assistant worked on it, which may
+   * have renamed it or filled in its details on the server. Null until then.
+   */
+  readonly details: NoteWithContent | null;
   readonly loading: boolean;
   readonly error: string | null;
+  /** The note does not exist (any more). */
+  readonly missing: boolean;
   readonly status: DocumentStatus;
   /**
    * The assistant has written at least one version: the loaded note had one,
@@ -61,6 +70,8 @@ interface UseAIModeDocumentOptions {
   readonly note: ChatNoteRef | null;
   readonly chat: AgentChat | null;
   readonly latestExecution: ChatExecution | null;
+  /** The assistant has a turn running on this document, in any of its chats. */
+  readonly assistantWorking: boolean;
 }
 
 /** Any succeeded `edit_note` in the chat carries the version it produced. */
@@ -89,23 +100,33 @@ function currentEditDraft(
 }
 
 /**
- * The document behind a conversation: loads it for the editor and derives
- * the pane's state from the active turn. Keeping the document current as the
- * assistant writes is the review hook's job (see useNoteAgentReview), which
- * splices each new version into the live editor instead of reloading it.
+ * The open document: loads it for the editor and derives the pane's state
+ * from the active turn. Keeping the document current as the assistant writes
+ * is the review hook's job (see useNoteAgentReview), which splices each new
+ * version into the live editor instead of reloading it.
  */
 export function useAIModeDocument({
   note,
   chat,
   latestExecution,
+  assistantWorking,
 }: UseAIModeDocumentOptions): AIModeDocument {
   const noteId = note?.id ?? null;
-  const [content, setContent] = useState<NoteWithContent | null>(null);
+  const [loadedContent, setContent] = useState<NoteWithContent | null>(null);
+  const [loadedDetails, setDetails] = useState<NoteWithContent | null>(null);
+  // Right after a switch, until the reset below has run, these still hold
+  // the previous note: nothing of it may be shown or saved as this one's.
+  const content = loadedContent?.id === noteId ? loadedContent : null;
+  const details = loadedDetails?.id === noteId ? loadedDetails : null;
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  const [missing, setMissing] = useState(false);
   // Kept beside the loaded note rather than written into it: the editor and
   // the review are seeded from that object and must not see it change.
   const [renamed, setRenamed] = useState<{ noteId: number; title: string } | null>(null);
+  // The title the server last reported, to tell a rename made there (by the
+  // assistant) from a stale copy of one the user made here and is saving.
+  const serverTitleRef = useRef<string | null>(null);
   const seqRef = useRef(0);
 
   const fetchNote = useCallback(async () => {
@@ -115,11 +136,14 @@ export function useAIModeDocument({
     try {
       const fetched = await NoteService.getNote(String(noteId));
       if (seq !== seqRef.current) return;
+      serverTitleRef.current = fetched.title;
       setContent(fetched);
       setError(null);
+      setMissing(false);
     } catch (err) {
       if (seq !== seqRef.current) return;
       setError(err instanceof Error ? err.message : 'Couldn’t load the document.');
+      setMissing(err instanceof NoteError && err.status === 404);
     } finally {
       if (seq === seqRef.current) setLoading(false);
     }
@@ -128,12 +152,45 @@ export function useAIModeDocument({
   // Reset and load whenever the note changes.
   useEffect(() => {
     seqRef.current += 1;
+    serverTitleRef.current = null;
     setContent(null);
+    setDetails(null);
     setError(null);
+    setMissing(false);
     setLoading(noteId != null);
     if (noteId != null) fetchNote();
   }, [noteId, fetchNote]);
 
+  // A turn on this document settled. The assistant may have renamed it or
+  // filled in its details, on the server: fetch them again for the masthead,
+  // the top bar and the sidebar. The loaded note itself is left alone; the
+  // editor's content arrives through the review.
+  const detailsSeqRef = useRef(0);
+  const refreshDetails = useCallback(async () => {
+    if (noteId == null) return;
+    const seq = ++detailsSeqRef.current;
+    try {
+      const fetched = await NoteService.getNote(String(noteId));
+      if (seq !== detailsSeqRef.current) return;
+      setDetails(fetched);
+      if (fetched.title !== serverTitleRef.current) {
+        serverTitleRef.current = fetched.title;
+        setRenamed({ noteId, title: fetched.title });
+      }
+    } catch {
+      // The details shown stay as they are until the next turn settles.
+    }
+  }, [noteId]);
+  useEffect(() => {
+    detailsSeqRef.current += 1;
+  }, [noteId]);
+  const wasWorkingRef = useRef(assistantWorking);
+  useEffect(() => {
+    const wasWorking = wasWorkingRef.current;
+    wasWorkingRef.current = assistantWorking;
+    if (wasWorking && !assistantWorking) void refreshDetails();
+  }, [assistantWorking, refreshDetails]);
+
   const draft = currentEditDraft(latestExecution);
   const draftText = draft?.text || null;
   const draftBlocks = Array.isArray(draft?.blocks) ? draft.blocks : null;
@@ -169,8 +226,11 @@ export function useAIModeDocument({
     content,
     title,
     rename,
+    updatedDate: details?.updatedDate ?? content?.updatedDate ?? null,
+    details,
     loading,
     error,
+    missing,
     status,
     hasWrittenVersion,
     draftText,
diff --git a/components/AIMode/shell/WorkspacePanes.tsx b/components/AIMode/shell/WorkspacePanes.tsx
index 112451488..5ec094e51 100644
--- a/components/AIMode/shell/WorkspacePanes.tsx
+++ b/components/AIMode/shell/WorkspacePanes.tsx
@@ -1,163 +1,101 @@
 'use client';
 
 import type { ReactNode } from 'react';
-import { PanelLeftOpen } from 'lucide-react';
-import { PublishMenu } from '@/app/layouts/PublishMenu';
 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 '../workspaceUrl';
 
 type ResizableWidth = ReturnType<typeof useResizableWidth>;
 
 interface WorkspacePanesProps {
-  readonly layout: WorkspaceLayout;
   readonly chat: ReactNode;
-  /** The document column; null while no document is open. */
+  /** The document column; null while no document is open or it is hidden. */
   readonly document: ReactNode | null;
   /** The document as the drawer shows it below the tablet breakpoint. */
   readonly documentDrawer: ReactNode | null;
   readonly isBelowTablet: boolean;
-  readonly sideWidth: ResizableWidth & { readonly min: number; readonly max: number };
+  readonly documentWidth: ResizableWidth & { readonly min: number; readonly max: number };
   /**
-   * The conversations and drafts, for the widths at which the app's left
-   * column has no room for them; null once it holds them.
+   * The user's documents, for the widths at which the app's left column is an
+   * icon rail, or absent on a phone; null when they are in it.
    */
-  readonly lists: ReactNode | null;
-  /** Shows the lists: a panel over the panes, or below the tablet breakpoint the whole screen. */
-  readonly listOpen: boolean;
-  readonly onCloseList: () => void;
+  readonly documents: ReactNode | null;
+  /** Shows the documents in a panel over the panes. */
+  readonly documentsOpen: boolean;
+  readonly onCloseDocuments: () => void;
   readonly onCloseDocumentDrawer: () => void;
 }
 
 /**
- * The chat and the document, side by side. They keep their places in the
- * tree whichever is the main pane — swapping them would remount the editor
- * and the transcript — and trade places on screen with flex order. The side
- * pane drags; the main pane takes the rest. Below the tablet breakpoint the
- * document lives in a bottom drawer. Where the app's left column cannot hold
- * the lists they open over the panes.
+ * The chat, and the document beside it on the right. The document's column
+ * drags; the chat takes the rest. Below the tablet breakpoint the document
+ * lives in a bottom drawer. Where the app's left column is an icon rail, the
+ * user's documents open over the panes.
  */
 export function WorkspacePanes({
-  layout,
   chat,
   document,
   documentDrawer,
   isBelowTablet,
-  sideWidth,
-  lists,
-  listOpen,
-  onCloseList,
+  documentWidth,
+  documents,
+  documentsOpen,
+  onCloseDocuments,
   onCloseDocumentDrawer,
 }: WorkspacePanesProps) {
-  const documentOpen = document != null;
-  // With no document beside it there is nothing to trade places with: the chat fills the space.
-  const chatIsMain = layout === 'chat' || !documentOpen || isBelowTablet;
-  const showLists = lists != null && listOpen;
+  const documentShown = document != null;
 
   return (
     <>
       <div className="relative flex min-h-0 flex-1">
-        <main
-          style={chatIsMain ? undefined : { width: sideWidth.width }}
-          className={cn(
-            'relative flex min-w-0 flex-col',
-            chatIsMain ? 'order-1 flex-1' : 'order-2 shrink-0 border-l border-gray-200'
-          )}
-        >
-          {!chatIsMain && <SideResizeHandle label="Resize chat" width={sideWidth} />}
-          {chat}
-        </main>
+        <main className="relative flex min-w-0 flex-1 flex-col">{chat}</main>
 
-        {documentOpen && !isBelowTablet && (
+        {documentShown && !isBelowTablet && (
           <aside
-            style={chatIsMain ? { width: sideWidth.width } : undefined}
-            className={cn(
-              'relative flex min-w-0 flex-col overflow-hidden bg-white',
-              chatIsMain ? 'order-2 shrink-0 border-l border-gray-200' : 'order-1 flex-1'
-            )}
+            style={{ width: documentWidth.width }}
+            className="relative flex min-w-0 shrink-0 flex-col overflow-hidden border-l border-gray-200 bg-white"
           >
-            {chatIsMain && <SideResizeHandle label="Resize document" width={sideWidth} />}
+            <ResizeHandle
+              label="Resize document"
+              side="left"
+              value={documentWidth.width}
+              min={documentWidth.min}
+              max={documentWidth.max}
+              isResizing={documentWidth.isResizing}
+              onStart={documentWidth.startResize}
+              onNudge={documentWidth.nudgeWidth}
+            />
             {document}
           </aside>
         )}
 
-        {showLists && isBelowTablet && (
-          <div
-            role="dialog"
-            aria-label="Conversations and documents"
-            className="absolute inset-0 z-10 flex flex-col bg-white"
-          >
-            <div className="flex h-12 shrink-0 items-center gap-1 border-b border-gray-200 pl-0.5 pr-3">
-              <button
-                type="button"
-                onClick={onCloseList}
-                aria-label="Hide conversations and documents"
-                aria-pressed="true"
-                className="flex h-11 w-11 items-center justify-center rounded-lg text-primary-700"
-              >
-                <PanelLeftOpen className="h-[18px] w-[18px]" />
-              </button>
-              <h2 className="text-sm font-medium text-gray-800">Conversations and documents</h2>
-            </div>
-            {/* A phone has no left column, so the way to start something new leads the lists. */}
-            <div className="px-3 pt-3">
-              <PublishMenu onItemSelected={onCloseList} />
-            </div>
-            <div className="min-h-0 flex-1">{lists}</div>
-          </div>
-        )}
-
-        {/* Between the tablet breakpoint and the width at which the left
-            column holds the lists, they slide over the panes from its edge.
-            The top bar's button, which stays clear of the scrim, also closes it. */}
-        {showLists && !isBelowTablet && (
+        {/* Below the width at which the left column holds them, the
+            documents slide over the panes from its edge. */}
+        {documents != null && documentsOpen && (
           <>
             <div
               aria-hidden="true"
-              onClick={onCloseList}
+              onClick={onCloseDocuments}
               className="workspace-fade-in absolute inset-0 z-10 bg-gray-900/20"
             />
             <aside
-              aria-label="Conversations and documents"
-              className="workspace-fade-in absolute inset-y-0 left-0 z-20 flex w-[240px] flex-col border-r border-gray-200 bg-white pt-1 shadow-xl"
+              aria-label="Your documents"
+              className="workspace-fade-in absolute inset-y-0 left-0 z-20 flex w-[240px] flex-col overflow-y-auto border-r border-gray-200 bg-white shadow-xl"
             >
-              {lists}
+              {documents}
             </aside>
           </>
         )}
       </div>
 
       <SwipeableDrawer
-        isOpen={documentOpen && isBelowTablet}
+        isOpen={documentShown && isBelowTablet}
         onClose={onCloseDocumentDrawer}
         height="85vh"
         className="tablet:!hidden"
       >
-        {documentOpen && isBelowTablet && documentDrawer}
+        {documentShown && isBelowTablet && documentDrawer}
       </SwipeableDrawer>
     </>
   );
 }
-
-function SideResizeHandle({
-  label,
-  width,
-}: {
-  readonly label: string;
-  readonly width: WorkspacePanesProps['sideWidth'];
-}) {
-  return (
-    <ResizeHandle
-      label={label}
-      side="left"
-      value={width.width}
-      min={width.min}
-      max={width.max}
-      isResizing={width.isResizing}
-      onStart={width.startResize}
-      onNudge={width.nudgeWidth}
-    />
-  );
-}
diff --git a/components/AIMode/shell/WorkspaceTopBar.tsx b/components/AIMode/shell/WorkspaceTopBar.tsx
index c99bb9572..0a7217ddc 100644
--- a/components/AIMode/shell/WorkspaceTopBar.tsx
+++ b/components/AIMode/shell/WorkspaceTopBar.tsx
@@ -6,15 +6,12 @@ import { useTopBarSlot } from '@/contexts/TopBarSlotContext';
 import { cn } from '@/utils/styles';
 
 interface WorkspaceTopBarProps {
-  /**
-   * What is open: the conversation's title when the chat is the main pane,
-   * the document's when it is, "New RFP" or "New proposal" on the start screen.
-   */
+  /** What is open: the document's title, or "New RFP" or "New proposal" on the start screen. */
   readonly title: string;
   /**
-   * Shows or hides the conversations and drafts while the app's left column
-   * is an icon rail with no room for them; absent once the column holds
-   * them, and on a phone, where the chat's header has the button.
+   * Shows or hides the user's documents while the app's left column is an
+   * icon rail with no room for them; absent once the column holds them, and
+   * on a phone, where the ☰ menu has them.
    */
   readonly onToggleList?: () => void;
   readonly listOpen?: boolean;
@@ -38,9 +35,7 @@ export function WorkspaceTopBar({ title, onToggleList, listOpen = false }: Works
 
   const listButton = useMemo(() => {
     if (!onToggleList) return null;
-    const label = listOpen
-      ? 'Hide conversations and documents'
-      : 'Show conversations and documents';
+    const label = listOpen ? 'Hide documents' : 'Show documents';
     return (
       <button
         type="button"
diff --git a/components/AIMode/sidebar/ConversationMenu.tsx b/components/AIMode/sidebar/ConversationMenu.tsx
deleted file mode 100644
index c3eb6bc27..000000000
--- a/components/AIMode/sidebar/ConversationMenu.tsx
+++ /dev/null
@@ -1,131 +0,0 @@
-'use client';
-
-import { useEffect, useState } from 'react';
-import { MoreHorizontal, Pencil, Trash2 } from 'lucide-react';
-import type { ChatNoteRef } from '@/types/agentChat';
-import { BaseMenu, BaseMenuItem } from '@/components/ui/form/BaseMenu';
-import { BaseModal } from '@/components/ui/BaseModal';
-import { Button } from '@/components/ui/Button';
-import { cn } from '@/utils/styles';
-
-interface ConversationMenuProps {
-  readonly title: string;
-  readonly onRename: () => void;
-  /** Called only after the user confirms, with whether to delete the notes too. */
-  readonly onDelete: (options: { deleteNotes: boolean }) => void;
-  /** The notes the conversation created; offered for deletion when any exist. */
-  readonly loadNotes?: () => Promise<ChatNoteRef[]>;
-  readonly className?: string;
-}
-
-/**
- * The ellipsis menu for one conversation — rename inline, or delete behind a
- * confirmation. Shared by the sidebar rows and the chat header so the two
- * places offer exactly the same actions.
- */
-export function ConversationMenu({
-  title,
-  onRename,
-  onDelete,
-  loadNotes,
-  className,
-}: ConversationMenuProps) {
-  const [confirming, setConfirming] = useState(false);
-  // The notes are looked up when the dialog opens, so a row whose detail was
-  // never loaded still gets the offer — and only the offer when there is
-  // something to delete. Off by default: the note is the user's work.
-  const [notes, setNotes] = useState<ChatNoteRef[] | null>(null);
-  const [deleteNotes, setDeleteNotes] = useState(false);
-  useEffect(() => {
-    if (!confirming) return;
-    setNotes(null);
-    setDeleteNotes(false);
-    let cancelled = false;
-    (loadNotes ? loadNotes() : Promise.resolve([]))
-      .then((loaded) => {
-        if (!cancelled) setNotes(loaded);
-      })
-      .catch(() => {
-        if (!cancelled) setNotes([]);
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [confirming, loadNotes]);
-  const noteTitle = notes?.[0]?.title?.trim();
-
-  return (
-    <>
-      <BaseMenu
-        align="end"
-        trigger={
-          <button
-            type="button"
-            aria-label="Conversation options"
-            className={cn(
-              'rounded-md p-1 text-gray-400 transition-colors hover:bg-gray-200/70 hover:text-gray-700',
-              className
-            )}
-          >
-            <MoreHorizontal className="h-4 w-4" />
-          </button>
-        }
-      >
-        <BaseMenuItem onSelect={onRename} className="gap-2 text-gray-700">
-          <Pencil className="h-3.5 w-3.5" aria-hidden="true" />
-          Rename
-        </BaseMenuItem>
-        <BaseMenuItem
-          onSelect={() => setConfirming(true)}
-          className="gap-2 text-red-600 focus:bg-red-50 focus:text-red-700"
-        >
-          <Trash2 className="h-3.5 w-3.5" aria-hidden="true" />
-          Delete
-        </BaseMenuItem>
-      </BaseMenu>
-
-      <BaseModal
-        isOpen={confirming}
-        onClose={() => setConfirming(false)}
-        title="Delete conversation?"
-        size="sm"
-        footer={
-          <div className="flex justify-end gap-2">
-            <Button variant="outlined" size="sm" onClick={() => setConfirming(false)}>
-              Cancel
-            </Button>
-            <Button
-              size="sm"
-              className="bg-red-600 text-white hover:bg-red-700"
-              onClick={() => {
-                setConfirming(false);
-                onDelete({ deleteNotes: deleteNotes && (notes?.length ?? 0) > 0 });
-              }}
-            >
-              Delete
-            </Button>
-          </div>
-        }
-      >
-        <p className="text-sm text-gray-600">“{title}” and its messages will be deleted.</p>
-        {notes && notes.length > 0 ? (
-          <label className="mt-4 flex cursor-pointer items-start gap-2.5 text-sm text-gray-700">
-            <input
-              type="checkbox"
-              checked={deleteNotes}
-              onChange={(event) => setDeleteNotes(event.target.checked)}
-              className="mt-0.5 h-4 w-4 rounded border-gray-300 accent-primary-600"
-            />
-            <span>
-              Also delete the document it created
-              {noteTitle ? <span className="text-gray-500">, “{noteTitle}”</span> : null}. Otherwise
-              it stays in your notebook.
-            </span>
-          </label>
-        ) : notes == null && loadNotes ? (
-          <p className="mt-3 text-xs text-gray-400">Checking for a document…</p>
-        ) : null}
-      </BaseModal>
-    </>
-  );
-}
diff --git a/components/AIMode/sidebar/ConversationsSection.tsx b/components/AIMode/sidebar/ConversationsSection.tsx
deleted file mode 100644
index cfe8fe427..000000000
--- a/components/AIMode/sidebar/ConversationsSection.tsx
+++ /dev/null
@@ -1,137 +0,0 @@
-'use client';
-
-import { useState } from 'react';
-import { Loader } from '@/components/ui/Loader';
-import { ConversationListSkeleton } from '@/components/skeletons/AIModeSkeleton';
-import { Button } from '@/components/ui/Button';
-import type { ChatListAccess } from '@/hooks/useAgentChat';
-import type { AgentChatListItem, ChatNoteRef } from '@/types/agentChat';
-import { ConversationTitleField } from '../chat/ConversationTitleField';
-import { ConversationMenu } from './ConversationMenu';
-import { SidebarGroupHeading } from './SidebarGroupHeading';
-import { SidebarRow } from './SidebarRow';
-
-const UNTITLED = 'Untitled conversation';
-/** Recent conversations shown before the list asks to be expanded. */
-const RECENT_COUNT = 8;
-
-interface ConversationsSectionProps {
-  readonly chats: AgentChatListItem[];
-  readonly access: ChatListAccess;
-  readonly accessDetail: string | null;
-  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: (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[]>;
-  readonly onRetry: () => void;
-}
-
-/**
- * The user's conversations, newest activity first as the server orders them,
- * the most recent few at a time. Rows rename and delete through a menu.
- */
-export function ConversationsSection({
-  chats,
-  access,
-  accessDetail,
-  activeChatId,
-  titleFor,
-  onSelect,
-  onRename,
-  onDelete,
-  loadNotes,
-  onRetry,
-}: ConversationsSectionProps) {
-  const [renamingId, setRenamingId] = useState<number | null>(null);
-  const [showAll, setShowAll] = useState(false);
-  // The open conversation always shows, so selecting an older one from the
-  // full list does not fold it back out of sight.
-  const shown = showAll
-    ? chats
-    : chats.filter((item, index) => index < RECENT_COUNT || item.id === activeChatId);
-  const hiddenCount = chats.length - shown.length;
-
-  return (
-    <section aria-label="Conversations">
-      <SidebarGroupHeading>Conversations</SidebarGroupHeading>
-
-      {access === 'loading' && <ConversationListSkeleton />}
-
-      {access === 'hidden' && (
-        <p className="px-3 py-2 text-xs leading-relaxed text-red-600">
-          {accessDetail ?? 'You don’t have access to the assistant.'}
-        </p>
-      )}
-
-      {access === 'error' && (
-        <div className="flex flex-col items-start gap-2 px-3 py-2">
-          <p className="text-xs leading-relaxed text-gray-600">
-            {accessDetail ?? 'Couldn’t load your conversations.'}
-          </p>
-          <Button variant="outlined" size="sm" onClick={onRetry}>
-            Try again
-          </Button>
-        </div>
-      )}
-
-      {access === 'ok' && chats.length === 0 && (
-        <p className="px-3 py-2 text-xs text-gray-400">No conversations yet.</p>
-      )}
-
-      {shown.map((item) => {
-        const isActive = item.id === activeChatId;
-        const resolved = titleFor(item.id, item.title);
-        const title = resolved?.trim() || UNTITLED;
-        return (
-          <SidebarRow
-            key={item.id}
-            title={title}
-            isActive={isActive}
-            onSelect={() => onSelect(item)}
-            titleAdornment={
-              item.has_active_turn && (
-                <Loader size="sm" className="!h-3 !w-3 shrink-0 text-primary-500" />
-              )
-            }
-            editing={
-              renamingId === item.id && (
-                <ConversationTitleField
-                  initialValue={title === UNTITLED ? '' : title}
-                  onCancel={() => setRenamingId(null)}
-                  onCommit={async (value) => {
-                    setRenamingId(null);
-                    const next = value.trim();
-                    if (!next || next === (resolved ?? '')) return;
-                    await onRename(item.id, next);
-                  }}
-                  className="text-[13px]"
-                />
-              )
-            }
-            menu={
-              <ConversationMenu
-                title={title}
-                onRename={() => setRenamingId(item.id)}
-                onDelete={(options) => onDelete(item.id, options)}
-                loadNotes={() => loadNotes(item.id)}
-              />
-            }
-          />
-        );
-      })}
-
-      {hiddenCount > 0 && (
-        <button
-          type="button"
-          onClick={() => setShowAll(true)}
-          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"
-        >
-          Show all ({chats.length})
-        </button>
-      )}
-    </section>
-  );
-}
diff --git a/components/AIMode/sidebar/DraftsSection.tsx b/components/AIMode/sidebar/DraftsSection.tsx
deleted file mode 100644
index a78c51887..000000000
--- a/components/AIMode/sidebar/DraftsSection.tsx
+++ /dev/null
@@ -1,131 +0,0 @@
-'use client';
-
-import { useEffect, useMemo } from 'react';
-import { FileText } from 'lucide-react';
-import { NoteStatusDot } from '@/components/Notebook/NoteStatus';
-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 { isChangelogNote, isPublishedNote, type Note } from '@/types/note';
-import { SidebarGroupHeading } from './SidebarGroupHeading';
-import { SidebarRow } from './SidebarRow';
-
-interface DraftsSectionProps {
-  readonly activeNoteId: number | null;
-  /** A note the open conversation just created; the list fetches again to show it. */
-  readonly recentNoteId: number | null;
-  /** The open document and its title as it stands; its row follows a rename. */
-  readonly openNote?: { readonly id: number; readonly title: string } | null;
-  readonly onSelect: (noteId: number) => void;
-}
-
-/** A plain document, with a dot at its corner for whether it has gone out: blue published, amber draft. */
-function DraftIcon({ note }: { readonly note: Note }) {
-  return (
-    <span className="relative flex h-[22px] w-[22px] shrink-0 items-center justify-center text-gray-500">
-      <FileText className="h-4 w-4" aria-hidden="true" />
-      <NoteStatusDot
-        published={isPublishedNote(note)}
-        className="absolute -bottom-px -right-px ring-2 ring-white"
-      />
-    </span>
-  );
-}
-
-/**
- * What the user has written, as the notebook lists it: every note they can
- * open, newest first, published or not. Opening one puts the document in
- * the main pane with a fresh chat beside it.
- */
-export function DraftsSection({
-  activeNoteId,
-  recentNoteId,
-  openNote = null,
-  onSelect,
-}: DraftsSectionProps) {
-  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]);
-
-  // The open document was renamed in its masthead: its row says so at once,
-  // and keeps saying so after another document is opened.
-  const { setNotes } = notes;
-  const openNoteId = openNote?.id ?? null;
-  const openNoteTitle = openNote?.title ?? '';
-  useEffect(() => {
-    if (openNoteId == null || !openNoteTitle) return;
-    setNotes((current) =>
-      current.some((note) => note.id === openNoteId && note.title !== openNoteTitle)
-        ? current.map((note) => (note.id === openNoteId ? { ...note, title: openNoteTitle } : note))
-        : current
-    );
-  }, [openNoteId, openNoteTitle, setNotes, notes.notes]);
-
-  return (
-    <section aria-label="Drafts">
-      <SidebarGroupHeading>Drafts</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 drafts.</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 drafts yet.</p>
-      )}
-
-      {rows.map((note) => (
-        <SidebarRow
-          key={note.id}
-          title={note.title?.trim() || 'Untitled'}
-          leading={<DraftIcon 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/SidebarGroupHeading.tsx b/components/AIMode/sidebar/SidebarGroupHeading.tsx
deleted file mode 100644
index 171ac1570..000000000
--- a/components/AIMode/sidebar/SidebarGroupHeading.tsx
+++ /dev/null
@@ -1,19 +0,0 @@
-import type { ReactNode } from 'react';
-
-interface SidebarGroupHeadingProps {
-  readonly children: ReactNode;
-  /** A small control at the heading's right end. */
-  readonly action?: ReactNode;
-}
-
-/** A quiet label over a group of sidebar rows. */
-export function SidebarGroupHeading({ children, action }: SidebarGroupHeadingProps) {
-  return (
-    <div className="flex items-center justify-between px-3 pb-1.5 pt-3.5">
-      <h2 className="text-[11px] font-medium uppercase tracking-[0.07em] text-gray-500">
-        {children}
-      </h2>
-      {action}
-    </div>
-  );
-}
diff --git a/components/AIMode/sidebar/SidebarRow.tsx b/components/AIMode/sidebar/SidebarRow.tsx
deleted file mode 100644
index b1bb51ef6..000000000
--- a/components/AIMode/sidebar/SidebarRow.tsx
+++ /dev/null
@@ -1,69 +0,0 @@
-'use client';
-
-import type { ReactNode } from 'react';
-import { cn } from '@/utils/styles';
-
-interface SidebarRowProps {
-  readonly title: string;
-  /** Something before the title — a document's kind, say. */
-  readonly leading?: ReactNode;
-  /** Beside the title, inside its line — a spinner for a running turn. */
-  readonly titleAdornment?: ReactNode;
-  /** Controls at the row's right edge, shown on hover, focus, or while active. */
-  readonly menu?: ReactNode;
-  readonly isActive: boolean;
-  readonly onSelect: () => void;
-  /** Replaces the row's face — an inline rename field. */
-  readonly editing?: ReactNode;
-}
-
-/** One entry in the workspace sidebar: a conversation, a document. */
-export function SidebarRow({
-  title,
-  leading,
-  titleAdornment,
-  menu,
-  isActive,
-  onSelect,
-  editing,
-}: SidebarRowProps) {
-  return (
-    <div
-      className={cn(
-        'group relative mb-0.5 rounded-lg transition-colors',
-        isActive ? 'bg-gray-100' : 'hover:bg-gray-50'
-      )}
-    >
-      {editing ? (
-        <div className="px-2 py-1.5">{editing}</div>
-      ) : (
-        <button
-          type="button"
-          onClick={onSelect}
-          aria-current={isActive ? 'true' : undefined}
-          className={cn(
-            'flex w-full items-center gap-2.5 py-2 pr-9 text-left',
-            leading ? 'pl-2.5' : 'pl-3'
-          )}
-        >
-          {leading}
-          <span className="flex min-w-0 flex-1 items-center gap-1.5">
-            <span className="min-w-0 truncate text-[13px] font-medium text-gray-800">{title}</span>
-            {titleAdornment}
-          </span>
-        </button>
-      )}
-
-      {!editing && menu && (
-        <div
-          className={cn(
-            'absolute right-1.5 top-1/2 -translate-y-1/2 opacity-0 transition-opacity focus-within:opacity-100 group-hover:opacity-100',
-            isActive && 'opacity-100'
-          )}
-        >
-          {menu}
-        </div>
-      )}
-    </div>
-  );
-}
diff --git a/components/AIMode/sidebar/WorkspaceSidebar.tsx b/components/AIMode/sidebar/WorkspaceSidebar.tsx
deleted file mode 100644
index 772e2e3d5..000000000
--- a/components/AIMode/sidebar/WorkspaceSidebar.tsx
+++ /dev/null
@@ -1,67 +0,0 @@
-'use client';
-
-import { useAIMode } from '../AIModeContext';
-import type { AIModeChatState } from '../useAIModeChat';
-import { ConversationsSection } from './ConversationsSection';
-import { DraftsSection } from './DraftsSection';
-
-interface WorkspaceSidebarProps {
-  readonly state: AIModeChatState;
-  /** The document that is open and its title as it stands, for the Drafts row to follow a rename. */
-  readonly openNote?: { readonly id: number; readonly title: string } | null;
-  /** Runs after any choice that should put a drawer away. */
-  readonly onNavigate?: () => void;
-}
-
-/**
- * The workspace's lists, where the app's nav items normally are: pick up a
- * conversation of your own, or open a draft. Starting a new one is the
- * Publish button above them.
- */
-export function WorkspaceSidebar({ state, openNote = null, onNavigate }: WorkspaceSidebarProps) {
-  const { selectDocument } = useAIMode();
-  const { target, chatId, list } = state;
-  // The workspace does not admit this user: the reason stands alone, without
-  // drafts that would open onto a chat they cannot use.
-  const blocked = list.access === 'hidden';
-
-  return (
-    <div className="flex h-full flex-col">
-      <nav aria-label="Workspace" className="min-h-0 flex-1 overflow-y-auto px-2 pb-2">
-        <ConversationsSection
-          chats={list.chats}
-          access={list.access}
-          accessDetail={list.accessDetail}
-          activeChatId={chatId}
-          titleFor={state.titleFor}
-          onSelect={(item) => {
-            state.selectConversation(item);
-            onNavigate?.();
-          }}
-          onRename={state.rename}
-          onDelete={state.deleteChat}
-          loadNotes={state.notesForChat}
-          onRetry={list.refresh}
-        />
-
-        {!blocked && (
-          <>
-            <div aria-hidden="true" className="mx-2 mt-2.5 h-px bg-gray-200" />
-
-            <DraftsSection
-              activeNoteId={
-                target.kind === 'document' && target.layout === 'document' ? target.noteId : null
-              }
-              recentNoteId={target.kind === 'conversation' ? (state.note?.id ?? null) : null}
-              openNote={openNote}
-              onSelect={(noteId) => {
-                selectDocument(noteId);
-                onNavigate?.();
-              }}
-            />
-          </>
-        )}
-      </nav>
-    </div>
-  );
-}
diff --git a/components/AIMode/start/StartContextChips.tsx b/components/AIMode/start/StartContextChips.tsx
index 1b600a2a8..37a34a0d9 100644
--- a/components/AIMode/start/StartContextChips.tsx
+++ b/components/AIMode/start/StartContextChips.tsx
@@ -12,7 +12,7 @@ import { formatCompactAmount } from '@/utils/currency';
 import { cn } from '@/utils/styles';
 
 interface StartContextChipsProps {
-  /** The RFP the user means to apply to, chosen before the conversation exists. */
+  /** The RFP the user means to apply to, chosen before the draft exists. */
   readonly selectedGrant: SelectedGrantDetails | null;
   readonly onSelectGrant: (grant: SelectedGrantDetails | null) => void;
 }
diff --git a/components/AIMode/start/StartJourney.tsx b/components/AIMode/start/StartJourney.tsx
deleted file mode 100644
index 14500bd61..000000000
--- a/components/AIMode/start/StartJourney.tsx
+++ /dev/null
@@ -1,154 +0,0 @@
-'use client';
-
-import Link from 'next/link';
-import { ArrowUpRight } from 'lucide-react';
-import type { FundingIntent } from '@/components/Funding/fundingDirection';
-import { RadiatingDot } from '@/components/ui/RadiatingDot';
-import { cn } from '@/utils/styles';
-
-interface JourneyStep {
-  readonly title: string;
-  readonly detail: string;
-}
-
-interface JourneyNote {
-  readonly title: string;
-  readonly href: string;
-}
-
-interface Journey {
-  readonly heading: string;
-  /** The first step is this conversation; the rest follow from it. */
-  readonly steps: readonly JourneyStep[];
-  /** Somewhere to go from here, when there is one. */
-  readonly note?: JourneyNote;
-}
-
-/**
- * What the two "open a document" modals say on their first slide, folded
- * into the workspace: the road from this conversation to funded science,
- * for a funder and for a researcher.
- */
-const JOURNEYS: Record<FundingIntent, Journey> = {
-  fund: {
-    heading: 'How funding works',
-    steps: [
-      { title: 'Publish your RFP', detail: 'Set the scope, budget, and aim.' },
-      {
-        title: 'Researchers submit proposals',
-        detail: 'We notify scientists who match your call.',
-      },
-      { title: 'Peer review', detail: 'Reviewers assess rigor and feasibility.' },
-      { title: 'Delegate the funds', detail: 'Choose which proposals get funded.' },
-    ],
-    note: { title: 'Track it from your funder dashboard', href: '/my-funding' },
-  },
-  need_funding: {
-    heading: 'How funding works',
-    steps: [
-      { title: 'Draft your proposal', detail: 'Aims, budget, and timeline.' },
-      {
-        title: 'Apply to an RFP or open call',
-        detail: "Answer a funder's call, or put it to the community.",
-      },
-      { title: 'Peer review', detail: 'Reviewers assess rigor and feasibility.' },
-      { title: 'Get funded', detail: 'Funders and community back your proposal.' },
-    ],
-  },
-};
-
-const ACCENT: Record<
-  FundingIntent,
-  { readonly dot: string; readonly note: string; readonly noteArrow: string }
-> = {
-  fund: {
-    dot: 'bg-primary-600',
-    note: 'border-primary-200 bg-primary-50 hover:bg-primary-100',
-    noteArrow: 'text-primary-700',
-  },
-  need_funding: {
-    dot: 'bg-emerald-600',
-    note: 'border-emerald-200 bg-emerald-50 hover:bg-emerald-100',
-    noteArrow: 'text-emerald-700',
-  },
-};
-
-interface StartJourneyProps {
-  readonly intent: FundingIntent;
-  readonly className?: string;
-}
-
-/**
- * The rail beside the composer: a four-step timeline with this conversation
- * as step one. Hollow dots for what is to come, a radiating one for now, and
- * one connector running dot to dot; words only, no icons. Under it, for a
- * funder, the way to their dashboard.
- */
-export function StartJourney({ intent, className }: StartJourneyProps) {
-  const journey = JOURNEYS[intent];
-  const accent = ACCENT[intent];
-
-  return (
-    <aside
-      aria-label={journey.heading}
-      className={cn(
-        'flex flex-col gap-4 rounded-2xl border border-gray-200 bg-gray-50 px-5 pb-4 pt-5',
-        className
-      )}
-    >
-      <h3 className="text-[11px] font-semibold uppercase tracking-[0.08em] text-gray-500">
-        {journey.heading}
-      </h3>
-      <ol className="flex flex-col">
-        {journey.steps.map((step, index) => {
-          const current = index === 0;
-          const last = index === journey.steps.length - 1;
-          return (
-            <li key={step.title} className="flex gap-3">
-              <div className="flex w-2.5 shrink-0 flex-col items-center pt-[5px]">
-                {current ? (
-                  <RadiatingDot ring color={accent.dot} className="shrink-0" />
-                ) : (
-                  <span
-                    aria-hidden="true"
-                    className="h-2.5 w-2.5 shrink-0 rounded-full border-[1.5px] border-gray-300 bg-white"
-                  />
-                )}
-                {!last && <span aria-hidden="true" className="w-px flex-1 bg-gray-200" />}
-              </div>
-              <div className={cn('flex min-w-0 flex-col gap-0.5', !last && 'pb-4')}>
-                <span
-                  className={cn(
-                    'text-[13px] font-semibold',
-                    current ? 'text-gray-900' : 'text-gray-700'
-                  )}
-                >
-                  {step.title}
-                  {current && <span className="sr-only">(this conversation)</span>}
-                </span>
-                <span className="text-xs leading-relaxed text-gray-500">{step.detail}</span>
-              </div>
-            </li>
-          );
-        })}
-      </ol>
-      {journey.note && (
-        <Link
-          href={journey.note.href}
-          className={cn(
-            'flex items-center gap-2.5 rounded-xl border px-3 py-2.5 transition-colors',
-            accent.note
-          )}
-        >
-          <span className="min-w-0 flex-1 text-xs font-semibold text-gray-900">
-            {journey.note.title}
-          </span>
-          <ArrowUpRight
-            className={cn('h-3.5 w-3.5 shrink-0', accent.noteArrow)}
-            aria-hidden="true"
-          />
-        </Link>
-      )}
-    </aside>
-  );
-}
diff --git a/components/AIMode/start/StartScreen.tsx b/components/AIMode/start/StartScreen.tsx
index 01e92b995..f3ad4e005 100644
--- a/components/AIMode/start/StartScreen.tsx
+++ b/components/AIMode/start/StartScreen.tsx
@@ -4,50 +4,42 @@ import type { ReactNode } from 'react';
 import type { FundingIntent } from '@/components/Funding/fundingDirection';
 import { INTENT_COPY } from '../copy';
 import { ConciergeCard } from './ConciergeCard';
-import { StartJourney } from './StartJourney';
 import { VisibilityCard } from './VisibilityCard';
 
 interface StartScreenProps {
   readonly greeting: string;
   /**
-   * Which side of the money this conversation is on, decided by the door the
-   * user came through: the composer's colour, wording and chips follow it.
+   * Which side of the money the draft is on, decided by the door the user
+   * came through: the composer's colour, wording and chips follow it.
    */
   readonly intent: FundingIntent;
   /**
-   * The composer, whose first message starts the conversation. For a
-   * researcher it carries the profile and RFP chips in its toolbar.
+   * The composer, whose first message creates the draft. For a researcher it
+   * carries the profile and RFP chips in its toolbar.
    */
   readonly composer: ReactNode;
 }
 
 /**
- * The new-conversation screen: describe the research you want to fund, or
- * the research you need funding for. What the assistant will draft — an RFP
- * or a proposal — was settled by the way in, before a word is typed. Beside
- * the composer, the road from this conversation to funded science.
+ * The screen that starts a new draft: describe the research you want to
+ * fund, or the research you need funding for. What the assistant will draft
+ * — an RFP or a proposal — was settled by the way in, before a word is
+ * typed. One column; the document appears beside the chat once it exists.
  */
 export function StartScreen({ greeting, intent, composer }: StartScreenProps) {
   return (
-    <div className="flex min-h-[60vh] flex-col justify-center">
-      {/* Side by side once the pane is wide enough; the rail drops under the composer before that. */}
-      <div className="flex flex-col gap-2 wide:!flex-row wide:!items-center wide:!gap-10">
-        <div className="flex min-w-0 flex-1 flex-col gap-5">
-          <div className="flex flex-col gap-1">
-            <h2 className="font-serif text-4xl tracking-tight text-gray-900">{greeting}</h2>
-            <p className="text-[15px] text-gray-500">{INTENT_COPY[intent].tagline}</p>
-          </div>
-
-          <div className="-mx-3">{composer}</div>
+    <div className="mx-auto flex min-h-[60vh] w-full max-w-[680px] flex-col justify-center gap-5">
+      <div className="flex flex-col gap-1">
+        <h2 className="font-serif text-4xl tracking-tight text-gray-900">{greeting}</h2>
+        <p className="text-[15px] text-gray-500">{INTENT_COPY[intent].tagline}</p>
+      </div>
 
-          {/* Under the box, one card each: a funder can talk it through instead;
-              a researcher hears who will see the proposal. */}
-          {intent === 'fund' && <ConciergeCard className="-mt-2" />}
-          {intent === 'need_funding' && <VisibilityCard className="-mt-2" />}
-        </div>
+      <div className="-mx-3">{composer}</div>
 
-        <StartJourney intent={intent} className="w-full shrink-0 wide:!w-[340px]" />
-      </div>
+      {/* Under the box, one card each: a funder can talk it through instead;
+          a researcher hears who will see the proposal. */}
+      {intent === 'fund' && <ConciergeCard className="-mt-2" />}
+      {intent === 'need_funding' && <VisibilityCard className="-mt-2" />}
     </div>
   );
 }
diff --git a/components/AIMode/start/startComposer.ts b/components/AIMode/start/startComposer.ts
index 05d6ce21d..7ca8363c1 100644
--- a/components/AIMode/start/startComposer.ts
+++ b/components/AIMode/start/startComposer.ts
@@ -3,7 +3,7 @@ import { cn } from '@/utils/styles';
 import { INTENT_COPY } from '../copy';
 
 /**
- * How the composer looks when it starts a conversation: roomier than the
+ * How the composer looks when it starts a new draft: roomier than the
  * in-chat one, shadowed, its border and send button in the intent's colour —
  * blue when the user is here to fund, emerald when they need funding.
  */
diff --git a/components/AIMode/start/useFundingIntent.ts b/components/AIMode/start/useFundingIntent.ts
index 9d5133676..ed4ec8e97 100644
--- a/components/AIMode/start/useFundingIntent.ts
+++ b/components/AIMode/start/useFundingIntent.ts
@@ -11,9 +11,9 @@ const isIntent = (value: unknown): value is FundingIntent =>
   value === 'fund' || value === 'need_funding';
 
 /**
- * The side of the fund / need-funding toggle a new conversation starts on:
- * whichever the user picked last, remembered per browser. Read after mount,
- * so the server and the first client render agree.
+ * The side of the money a new draft starts on: whichever the user picked
+ * last, remembered per browser. Read after mount, so the server and the
+ * first client render agree.
  */
 export function useFundingIntent(): [FundingIntent, (intent: FundingIntent) => void] {
   const [intent, setIntentState] = useState<FundingIntent>(DEFAULT_INTENT);
diff --git a/components/AIMode/useAIModeChat.ts b/components/AIMode/useAIModeChat.ts
index abe8643fd..d19a5d3b4 100644
--- a/components/AIMode/useAIModeChat.ts
+++ b/components/AIMode/useAIModeChat.ts
@@ -2,151 +2,171 @@
 
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useAIMode } from './AIModeContext';
-import type { WorkspaceTarget } from './workspaceUrl';
-import { getChatTransport } from '@/services/chatTransport';
-import { useAgentChatList, type UseAgentChatListResult } from '@/hooks/useAgentChat';
-import { useChatSession, type ChatSession } from '@/hooks/useChatSession';
+import { untitledDraftTitle } from './copy';
+import { useFundingIntent } from './start/useFundingIntent';
+import { mostRecentChat, useWorkspaceTarget } from './useWorkspaceTarget';
+import { documentTarget, type WorkspaceTarget } from './workspaceUrl';
 import type { ChatNoticePolicy } from '@/components/AgentChat/chatNotices';
+import {
+  createFundingDraft,
+  DOCUMENT_TYPE_BY_INTENT,
+} from '@/components/Funding/createFundingDraft';
 import type { FundingIntent } from '@/components/Funding/fundingDirection';
-import type { AgentChatListItem, ChatNoteRef, AgentChat } from '@/types/agentChat';
+import { useFundingDocuments } from '@/contexts/FundingDocumentsContext';
+import { useOrganizationContext } from '@/contexts/OrganizationContext';
+import { useAgentChatList, type UseAgentChatListResult } from '@/hooks/useAgentChat';
+import { useChatSession, type ChatSession } from '@/hooks/useChatSession';
+import { getChatTransport } from '@/services/chatTransport';
+import type { AgentChat, ChatNoteRef } from '@/types/agentChat';
 import type { SelectedGrantDetails } from '@/types/grant';
-import { useFundingIntent } from './start/useFundingIntent';
+import type { Note } from '@/types/note';
 
-/** Matches the chat hook's own poll cadence, so a background turn's spinner clears as fast as the open one. */
+/** Matches the chat hook's own poll cadence, so a background turn's dot clears as fast as the open one. */
 const LIST_POLL_INTERVAL_MS = 5000;
 
-const NOTICES: ChatNoticePolicy = { noun: 'conversation', usageLimit: 'inline' };
+const NOTICES: ChatNoticePolicy = { noun: 'chat', usageLimit: 'inline' };
 
 export interface AIModeChatState extends ChatSession {
   readonly target: WorkspaceTarget;
+  /** The open chat; null on the start screen, on a new chat, and while the latest is being found. */
   readonly chatId: number | null;
-  /** Every conversation the user has, the notebook's included. */
+  /** The open document's most recent chat is being looked up. */
+  readonly resolvingChat: boolean;
+  /** The open document's chats; empty on the start screen. */
   readonly list: UseAgentChatListResult;
+  /** `list` is the open document's, not, for a render after a switch, the previous one's. */
+  readonly listReady: boolean;
+  /** A chat on the open document has a turn running. */
+  readonly anyTurnActive: boolean;
   /**
-   * What the next conversation is for; sent with its creation. Named by the
-   * URL the door led to (`?new=rfp`), else the last one used.
+   * What the next draft is: an RFP (`fund`) or a proposal (`need_funding`).
+   * Named by the URL the door led to (`?new=rfp`), else the last one used.
    */
   readonly intent: FundingIntent;
-  /** The RFP the next conversation's proposal answers, chosen on the start screen. */
+  /** The RFP the next proposal answers, chosen on the start screen. */
   readonly selectedGrant: SelectedGrantDetails | null;
   readonly setSelectedGrant: (grant: SelectedGrantDetails | null) => void;
-  /** Rename any conversation, open or not. */
-  readonly rename: (chatId: number, title: string) => Promise<boolean>;
-  /**
-   * Delete any conversation, optionally with the notes it created; deleting
-   * the open one lands on the new-conversation screen.
-   */
-  readonly deleteChat: (chatId: number, options?: { deleteNotes?: boolean }) => Promise<boolean>;
+  /** Open one of the document's chats, or a new one. */
+  readonly openChat: (chat: number | 'new') => void;
+  /** Rename the open chat. */
+  readonly rename: (title: string) => 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. A chat on
-   * a document created nothing; the document is not its to delete.
+   * Delete one of the document's chats; deleting the open one opens the next
+   * most recent, or a new chat. The document is never touched.
    */
-  readonly notesForChat: (chatId: number) => Promise<ChatNoteRef[]>;
-  /** Open a listed conversation where it lives: on its own, or on its document. */
-  readonly selectConversation: (item: AgentChatListItem) => void;
-  /** The document the open target is about, if it has one. */
+  readonly deleteChat: (chatId: number) => Promise<boolean>;
+  /** The open document; titled from the sidebar's list until it has loaded. */
   readonly note: ChatNoteRef | null;
-  /**
-   * The title to show for a conversation: a rename the user just made, shown
-   * before the server confirms it, else the given fallback.
-   */
-  readonly titleFor: (chatId: number, fallback: string | null) => string | null;
+  /** The open chat's title, a rename shown before the server confirms it; null for a new chat. */
+  readonly chatTitle: string | null;
 }
 
 /**
- * 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.
+ * Orchestration for the workspace: the open document's chats, the open
+ * chat's session, selection through the URL, renames and deletes, and the
+ * first message of a new draft, which creates the document and then its
+ * chat. The session itself — the chat, its draft and the send path — is
+ * `useChatSession`, shared with the notebook's panel; every chat here is the
+ * notebook's kind, scoped to its document.
  */
 export function useAIModeChat(): AIModeChatState {
-  const { target, selectTarget, selectChat } = useAIMode();
-  const { chatId } = target;
-  const targetNoteId = target.kind === 'document' ? target.noteId : null;
-  const transport = getChatTransport({ noteId: targetNoteId });
+  const { target: urlTarget, selectTarget } = useAIMode();
+  const noteId = urlTarget.kind === 'document' ? urlTarget.noteId : null;
+  const documentTransport = noteId != null ? getChatTransport({ noteId }) : null;
+  // The start screen has no document yet. Its session still holds the draft
+  // text, the model choice and the budget, on the assistant's transport;
+  // the first message creates its chat on the new document's instead.
+  const transport = documentTransport ?? getChatTransport({ noteId: null });
 
-  // The sidebar lists every conversation, whichever surface the open one is on.
-  const list = useAgentChatList(getChatTransport({ noteId: null }), true);
+  const list = useAgentChatList(documentTransport, documentTransport != null);
+  const listReady = documentTransport != null && list.scopeKey === documentTransport.key;
+  const { target, chatId, resolving } = useWorkspaceTarget(list, documentTransport);
   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 });
-  }, []);
+  listRef.current = listReady ? list.chats : [];
+  const targetRef = useRef(target);
+  targetRef.current = target;
 
-  // ---- what the next conversation starts out knowing ----
-  // A Publish menu item or a New RFP / New proposal button leads to the
-  // new-conversation screen for one side of the money; the URL says which,
+  // ---- what the next draft is ----
+  // A Publish menu item, the Drafts "+" or a New RFP / New proposal button
+  // leads to the start screen for one side of the money; the URL says which,
   // so the screen does not ask and a reload keeps it. It becomes the side
   // remembered for a bare `/workspace`.
   const [rememberedIntent, rememberIntent] = useFundingIntent();
-  const urlIntent = target.kind === 'conversation' ? (target.intent ?? null) : null;
+  const urlIntent = target.kind === 'new' ? (target.intent ?? null) : null;
   useEffect(() => {
     if (urlIntent) rememberIntent(urlIntent);
   }, [urlIntent, rememberIntent]);
   const intent = urlIntent ?? rememberedIntent;
   const [selectedGrant, setSelectedGrant] = useState<SelectedGrantDetails | null>(null);
-  const createInitRef = useRef({ intent, selectedGrant });
-  createInitRef.current = { intent, selectedGrant };
-  const getCreateInit = useCallback(() => {
-    const { intent: current, selectedGrant: grant } = createInitRef.current;
-    return { intent: current, selectedGrantId: grant?.id ?? null };
-  }, []);
 
-  const targetRef = useRef(target);
-  targetRef.current = target;
+  // ---- the first message of a new draft ----
+  // It creates the document, then a chat on it, then goes out there. A note
+  // created by an attempt whose chat then failed is kept here, so a retry
+  // reuses it rather than leaving a second draft behind. It belongs to the
+  // start screen it was made on.
+  const { selectedOrg } = useOrganizationContext();
+  const fundingDocuments = useFundingDocuments();
+  const { addDraft } = fundingDocuments;
+  const pendingNoteRef = useRef<Note | null>(null);
+  const startScreenKey = target.kind === 'new' ? intent : null;
+  useEffect(() => {
+    pendingNoteRef.current = null;
+  }, [startScreenKey]);
+  const draftInitRef = useRef({ intent, selectedGrant, orgSlug: selectedOrg?.slug ?? null });
+  draftInitRef.current = { intent, selectedGrant, orgSlug: selectedOrg?.slug ?? null };
+  const createDraftTransport = useCallback(async () => {
+    const { intent: side, selectedGrant: grant, orgSlug } = draftInitRef.current;
+    if (!orgSlug) throw new Error('No organization to create the draft in');
+    const note = await createFundingDraft({
+      orgSlug,
+      title: untitledDraftTitle(side),
+      documentType: DOCUMENT_TYPE_BY_INTENT[side],
+      // Only its author sees it until it is published.
+      grouping: 'PRIVATE',
+      selectedGrantId: grant?.id ?? null,
+      existingNote: pendingNoteRef.current,
+      onNoteCreated: (created) => {
+        pendingNoteRef.current = created;
+        addDraft(created);
+      },
+    });
+    return getChatTransport({ noteId: note.id });
+  }, [addDraft]);
+
   const onChatCreated = useCallback(
     (created: AgentChat) => {
       const current = targetRef.current;
       if (current.kind === 'document') {
-        // The chat stays on its document, laid out as it was.
-        selectTarget({ ...current, chatId: created.conversation_id });
+        selectTarget(documentTarget(current.noteId, created.conversation_id));
         return;
       }
-      // The RFP went with the conversation it was picked for.
+      const note = pendingNoteRef.current;
+      if (note == null) return;
+      // The RFP went with the draft it was picked for.
       setSelectedGrant(null);
-      selectChat(created.conversation_id);
+      selectTarget(documentTarget(note.id, created.conversation_id));
     },
-    [selectTarget, selectChat]
+    [selectTarget]
   );
+
   const session = useChatSession({
     transport,
     chatId,
     enabled: true,
     onChatCreated,
     onListStale: refreshList,
-    getCreateInit,
+    transportForNewChat: target.kind === 'new' ? createDraftTransport : undefined,
     notices: NOTICES,
   });
   const { chat } = session;
   const clearAttachments = session.attachments.clear;
 
-  const chatRef = useRef(chat.chat);
-  chatRef.current = chat.chat;
-
-  // ---- selection ----
-  const selectConversation = useCallback(
-    (item: AgentChatListItem) => {
-      if (item.workflow === 'notebook_chat' && item.note) {
-        // Opened as a conversation: the chat comes first, its document beside it.
-        selectTarget({ kind: 'document', noteId: item.note.id, chatId: item.id, layout: 'chat' });
-      } else {
-        selectChat(item.id);
-      }
-    },
-    [selectTarget, selectChat]
-  );
-
-  // ---- keep the listing fresh ----
-  // The session refreshes it as the open chat's turns settle; poll while any
-  // other conversation has a turn running, so its row spinner clears without
-  // the user having to open it.
-  const anyTurnActive = list.chats.some((item) => item.has_active_turn);
+  // ---- keep the document's chats fresh ----
+  // The session refreshes them as the open chat's turns settle; poll while
+  // any other chat on the document has a turn running, so its dot clears
+  // without the user having to open it.
+  const anyTurnActive = listReady && list.chats.some((item) => item.has_active_turn);
   useEffect(() => {
     if (!anyTurnActive) return;
     const timer = setInterval(() => {
@@ -155,112 +175,101 @@ export function useAIModeChat(): AIModeChatState {
     return () => clearInterval(timer);
   }, [anyTurnActive, refreshList]);
 
-  // ---- 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((id: number, title: string | null) => {
-    setPendingTitles((prev) => {
-      if (title == null ? !prev.has(id) : prev.get(id) === title) return prev;
-      const next = new Map(prev);
-      if (title == null) next.delete(id);
-      else next.set(id, title);
-      return next;
-    });
-  }, []);
-  useEffect(() => {
-    // Retire each override once the listing shows the confirmed title.
-    for (const item of list.chats) {
-      const pending = pendingTitles.get(item.id);
-      if (pending != null && item.title === pending) setPendingTitle(item.id, null);
-    }
-  }, [list.chats, pendingTitles, setPendingTitle]);
-  const titleFor = useCallback(
-    (id: number, fallback: string | null) => pendingTitles.get(id) ?? fallback,
-    [pendingTitles]
+  // ---- choosing a chat ----
+  const openChat = useCallback(
+    (next: number | 'new') => {
+      const current = targetRef.current;
+      if (current.kind === 'document') selectTarget(documentTarget(current.noteId, next));
+    },
+    [selectTarget]
   );
 
+  // The open chat was deleted somewhere else (or never was on this
+  // document): the document opens on its most recent chat instead.
+  const chatGone = chatId != null && chat.access === 'not_found';
+  useEffect(() => {
+    if (!chatGone || noteId == null) return;
+    let cancelled = false;
+    void refreshList().then(() => {
+      if (!cancelled) selectTarget(documentTarget(noteId, 'latest'));
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [chatGone, noteId, refreshList, selectTarget]);
+
+  // ---- rename, shown before the server confirms it ----
+  // A rename is the user's own words; making them wait for the PATCH just
+  // flashes the old title back at them.
+  const [pendingTitle, setPendingTitle] = useState<{ chatId: number; title: string } | null>(null);
   const rename = useCallback(
-    async (id: number, title: string): Promise<boolean> => {
-      setPendingTitle(id, title);
-      let renamed: boolean;
-      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 transportFor(id).renameChat(id, title);
-          renamed = true;
-        } catch {
-          renamed = false;
-        }
-      }
+    async (title: string): Promise<boolean> => {
+      if (chatId == null) return false;
+      setPendingTitle({ chatId, title });
+      const renamed = await chat.rename(title);
+      setPendingTitle((current) => (current?.chatId === chatId ? null : current));
       if (renamed) refreshList();
-      else setPendingTitle(id, null);
       return renamed;
     },
-    [chat, transportFor, refreshList, setPendingTitle]
-  );
-
-  const notesForChat = useCallback(
-    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 transportFor(id).getChat(id)).notes ?? [];
-      } catch {
-        return [];
-      }
-    },
-    [transportFor]
+    [chatId, chat, refreshList]
   );
+  const listedTitle = listReady
+    ? (list.chats.find((item) => item.id === chatId)?.title ?? null)
+    : null;
+  const chatTitle =
+    chatId == null
+      ? null
+      : pendingTitle?.chatId === chatId
+        ? pendingTitle.title
+        : (chat.chat?.title ?? listedTitle);
 
+  // ---- delete; the document stays ----
   const deleteChat = useCallback(
-    async (id: number, options?: { deleteNotes?: boolean }): Promise<boolean> => {
+    async (id: number): Promise<boolean> => {
+      if (documentTransport == null) return false;
       try {
-        await transportFor(id).deleteChat(id, options);
+        await documentTransport.deleteChat(id);
       } catch {
         return false;
       }
       clearAttachments(id);
-      if (targetRef.current.chatId === id) selectChat(null);
+      const current = targetRef.current;
+      if (current.kind === 'document' && current.chat === id) {
+        const next = mostRecentChat(listRef.current.filter((item) => item.id !== id));
+        selectTarget(documentTarget(current.noteId, next?.id ?? 'new'));
+      }
       refreshList();
       return true;
     },
-    [transportFor, selectChat, refreshList, clearAttachments]
+    [documentTransport, selectTarget, refreshList, clearAttachments]
   );
 
-  // ---- 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]);
+  // ---- the open document ----
+  const { drafts, published } = fundingDocuments;
+  const listedTitleOfNote =
+    noteId == null
+      ? ''
+      : ([...drafts, ...published].find((item) => item.id === noteId)?.title ?? '');
+  const note = useMemo<ChatNoteRef | null>(
+    () => (noteId == null ? null : { id: noteId, title: listedTitleOfNote }),
+    [noteId, listedTitleOfNote]
+  );
 
   return {
     ...session,
     target,
     chatId,
+    resolvingChat: resolving,
     list,
+    listReady,
+    anyTurnActive,
     intent,
     selectedGrant,
     setSelectedGrant,
+    openChat,
     rename,
     deleteChat,
-    notesForChat,
-    selectConversation,
     note,
-    titleFor,
+    chatTitle,
   };
 }
diff --git a/components/AIMode/useWorkspaceTarget.ts b/components/AIMode/useWorkspaceTarget.ts
new file mode 100644
index 000000000..260992822
--- /dev/null
+++ b/components/AIMode/useWorkspaceTarget.ts
@@ -0,0 +1,56 @@
+'use client';
+
+import { useEffect } from 'react';
+import type { UseAgentChatListResult } from '@/hooks/useAgentChat';
+import type { ChatTransport } from '@/services/chatTransport';
+import type { AgentChatListItem } from '@/types/agentChat';
+import { useAIMode } from './AIModeContext';
+import { documentTarget, type WorkspaceTarget } from './workspaceUrl';
+
+export interface ResolvedWorkspaceTarget {
+  readonly target: WorkspaceTarget;
+  /** The open chat; null on the start screen, on a new chat, and while `latest` is resolving. */
+  readonly chatId: number | null;
+  /** The document's chats are loading to say which is its most recent. */
+  readonly resolving: boolean;
+}
+
+/** The chat with the newest activity. */
+export function mostRecentChat(chats: readonly AgentChatListItem[]): AgentChatListItem | null {
+  let latest: AgentChatListItem | null = null;
+  for (const chat of chats) {
+    if (latest == null || Date.parse(chat.updated_date) > Date.parse(latest.updated_date)) {
+      latest = chat;
+    }
+  }
+  return latest;
+}
+
+/**
+ * What the workspace is open on, with a document's `latest` chat turned into
+ * one: its most recent chat once its chats have loaded, or a new one when it
+ * has none. The URL is rewritten to name it, so a reload stays on it.
+ *
+ * `list` is the open document's chats, served by `transport`.
+ */
+export function useWorkspaceTarget(
+  list: UseAgentChatListResult,
+  transport: ChatTransport | null
+): ResolvedWorkspaceTarget {
+  const { target, selectTarget } = useAIMode();
+  const latest = target.kind === 'document' && target.chat === 'latest' ? target : null;
+  // Right after a switch the listing still holds the previous document's chats.
+  const listed = transport != null && list.scopeKey === transport.key && list.access === 'ok';
+
+  useEffect(() => {
+    if (latest == null || !listed) return;
+    selectTarget(documentTarget(latest.noteId, mostRecentChat(list.chats)?.id ?? 'new'));
+  }, [latest, listed, list.chats, selectTarget]);
+
+  if (target.kind !== 'document') return { target, chatId: null, resolving: false };
+  return {
+    target,
+    chatId: typeof target.chat === 'number' ? target.chat : null,
+    resolving: target.chat === 'latest',
+  };
+}
diff --git a/components/AIMode/workspaceUrl.ts b/components/AIMode/workspaceUrl.ts
index dc7a16e5d..91da712da 100644
--- a/components/AIMode/workspaceUrl.ts
+++ b/components/AIMode/workspaceUrl.ts
@@ -3,60 +3,48 @@ import type { FundingIntent } from '@/components/Funding/fundingDirection';
 export const WORKSPACE_PATH = '/workspace';
 
 /**
- * `chat=<id>` selects a conversation; `note=<id>` opens a document, with
- * `chat` then naming the chat on that document. `view=chat` puts that chat,
- * not the document, in the main pane (a conversation opened from the list);
- * absent, the document comes first. `new=rfp|proposal` is the
- * new-conversation screen for one side of the money.
+ * `note=<id>` opens a document, with `chat` naming the chat on it: an id, or
+ * `new` for a chat not yet started; absent, its most recent chat.
+ * `new=rfp|proposal` is the screen that starts a new draft for one side of
+ * the money. Anything else is that screen too.
  */
 const CHAT_PARAM = 'chat';
 const NOTE_PARAM = 'note';
-const VIEW_PARAM = 'view';
 const NEW_PARAM = 'new';
+const NEW_CHAT = 'new';
 
-/** The overlay's params, from when the workspace opened over any page with `?ai=1`. */
-const LEGACY_OPEN_PARAM = 'ai';
-const LEGACY_CHAT_PARAM = 'aiChat';
-const LEGACY_NOTE_PARAM = 'aiNote';
-const LEGACY_VIEW_PARAM = 'aiView';
-
-/** Which pane is the main one; the other sits at a fixed width beside it. */
-export type WorkspaceLayout = 'chat' | 'document';
+/**
+ * Which chat a document is open on: one of its chats, its most recent one
+ * (until its chats have loaded and say which that is), or a new one.
+ */
+export type DocumentChat = number | 'latest' | 'new';
 
 /**
- * What the workspace is open on: one of the user's conversations (null = the
- * new-conversation screen, which may say which side of the money it is for),
- * or a document with a chat scoped to it (null = a chat not yet started). A
- * document target remembers how it was reached: opened as a document it
- * comes first, opened as a conversation its chat does.
+ * What the workspace is open on: the screen that starts a new draft (which
+ * may say which side of the money it is for), or a document and one of its
+ * chats. Every chat belongs to a document.
  */
 export type WorkspaceTarget =
   | {
-      readonly kind: 'conversation';
-      readonly chatId: number | null;
-      /** Only on the new-conversation screen: what the door it was opened through will draft. */
+      readonly kind: 'new';
+      /** What the door it was opened through will draft: an RFP or a proposal. */
       readonly intent?: FundingIntent;
     }
   | {
       readonly kind: 'document';
       readonly noteId: number;
-      readonly chatId: number | null;
-      readonly layout: WorkspaceLayout;
+      readonly chat: DocumentChat;
     };
 
-export const layoutFor = (target: WorkspaceTarget): WorkspaceLayout =>
-  target.kind === 'document' ? target.layout : 'chat';
+/** The screen that starts a new draft, for one side of the money or the one last used. */
+export const newDraftTarget = (intent?: FundingIntent): WorkspaceTarget =>
+  intent ? { kind: 'new', intent } : { kind: 'new' };
 
-/** The new-conversation screen, for one side of the money or the one last used. */
-export const newConversationTarget = (intent?: FundingIntent): WorkspaceTarget =>
-  intent ? { kind: 'conversation', chatId: null, intent } : { kind: 'conversation', chatId: null };
-
-/** A document with a fresh chat beside it. */
-export const documentTarget = (noteId: number): WorkspaceTarget => ({
+/** A document, on its most recent chat unless another is named. */
+export const documentTarget = (noteId: number, chat: DocumentChat = 'latest'): WorkspaceTarget => ({
   kind: 'document',
   noteId,
-  chatId: null,
-  layout: 'document',
+  chat,
 });
 
 const INTENT_BY_PARAM: Record<string, FundingIntent> = { rfp: 'fund', proposal: 'need_funding' };
@@ -70,36 +58,18 @@ function parseId(raw: string | null): number | null {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
 }
 
-function targetFrom(
-  chatId: number | null,
-  noteId: number | null,
-  view: string | null,
-  intent?: FundingIntent
-): WorkspaceTarget {
-  if (noteId != null) {
-    return { kind: 'document', noteId, chatId, layout: view === 'chat' ? 'chat' : 'document' };
-  }
-  if (chatId != null) return { kind: 'conversation', chatId };
-  return newConversationTarget(intent);
-}
-
 export function readWorkspaceTarget(params: Params): WorkspaceTarget {
-  return targetFrom(
-    parseId(params.get(CHAT_PARAM)),
-    parseId(params.get(NOTE_PARAM)),
-    params.get(VIEW_PARAM),
-    INTENT_BY_PARAM[params.get(NEW_PARAM) ?? '']
-  );
+  const noteId = parseId(params.get(NOTE_PARAM));
+  if (noteId == null) return newDraftTarget(INTENT_BY_PARAM[params.get(NEW_PARAM) ?? '']);
+  const chat = params.get(CHAT_PARAM);
+  return documentTarget(noteId, chat === NEW_CHAT ? 'new' : (parseId(chat) ?? 'latest'));
 }
 
 export function workspaceHref(target: WorkspaceTarget): string {
   const params = new URLSearchParams();
   if (target.kind === 'document') {
     params.set(NOTE_PARAM, String(target.noteId));
-    if (target.chatId != null) params.set(CHAT_PARAM, String(target.chatId));
-    if (target.layout === 'chat') params.set(VIEW_PARAM, 'chat');
-  } else if (target.chatId != null) {
-    params.set(CHAT_PARAM, String(target.chatId));
+    if (target.chat !== 'latest') params.set(CHAT_PARAM, String(target.chat));
   } else if (target.intent) {
     params.set(NEW_PARAM, PARAM_BY_INTENT[target.intent]);
   }
@@ -107,17 +77,5 @@ export function workspaceHref(target: WorkspaceTarget): string {
   return query ? `${WORKSPACE_PATH}?${query}` : WORKSPACE_PATH;
 }
 
-/** Where an overlay-era `?ai=1` link leads now; null for any other URL. */
-export function legacyWorkspaceHref(params: Params): string | null {
-  if (params.get(LEGACY_OPEN_PARAM) !== '1') return null;
-  return workspaceHref(
-    targetFrom(
-      parseId(params.get(LEGACY_CHAT_PARAM)),
-      parseId(params.get(LEGACY_NOTE_PARAM)),
-      params.get(LEGACY_VIEW_PARAM)
-    )
-  );
-}
-
 export const sameTarget = (a: WorkspaceTarget, b: WorkspaceTarget): boolean =>
   workspaceHref(a) === workspaceHref(b);
diff --git a/components/AgentChat/AssistantActivityDot.tsx b/components/AgentChat/AssistantActivityDot.tsx
new file mode 100644
index 000000000..9ebba4ce0
--- /dev/null
+++ b/components/AgentChat/AssistantActivityDot.tsx
@@ -0,0 +1,30 @@
+import { RadiatingDot } from '@/components/ui/RadiatingDot';
+import { cn } from '@/utils/styles';
+
+interface AssistantActivityDotProps {
+  /**
+   * `working` flashes while the assistant is at work; `review` stands still
+   * while its changes wait to be accepted or rejected.
+   */
+  readonly state: 'working' | 'review';
+  readonly className?: string;
+}
+
+const LABEL: Record<AssistantActivityDotProps['state'], string> = {
+  working: 'The assistant is working on this document',
+  review: 'The assistant’s changes are ready to review',
+};
+
+/** The one sign that the assistant is at work: on a document, and on a chat's row in History. */
+export function AssistantActivityDot({ state, className }: AssistantActivityDotProps) {
+  return (
+    <span
+      role="status"
+      aria-label={LABEL[state]}
+      title={LABEL[state]}
+      className={cn('inline-flex', className)}
+    >
+      <RadiatingDot ring size="md" color="bg-primary-500" isRadiating={state === 'working'} />
+    </span>
+  );
+}
diff --git a/components/AgentChat/ChatEmptyState.tsx b/components/AgentChat/ChatEmptyState.tsx
new file mode 100644
index 000000000..f1e3af237
--- /dev/null
+++ b/components/AgentChat/ChatEmptyState.tsx
@@ -0,0 +1,51 @@
+'use client';
+
+import { Logo } from '@/components/ui/Logo';
+import { ChatPresets } from './ChatPresets';
+
+interface ChatEmptyStateProps {
+  readonly noteIsEmpty: boolean;
+  readonly noteIsRfp: boolean;
+  readonly onSelectPreset: (message: string) => void;
+  readonly presetsDisabled: boolean;
+  /** What the help line calls the thing being written: the notebook's "note", the workspace's "document". */
+  readonly noun?: string;
+}
+
+/**
+ * A chat on a document before its first message: who the assistant is, what
+ * it can do, and a few ways to start, chosen by what the document is and
+ * whether anything is written in it yet.
+ */
+export function ChatEmptyState({
+  noteIsEmpty,
+  noteIsRfp,
+  onSelectPreset,
+  presetsDisabled,
+  noun = 'note',
+}: ChatEmptyStateProps) {
+  return (
+    <div className="flex h-full flex-col items-center justify-center gap-5 px-6 text-center">
+      <div className="flex flex-col items-center gap-3">
+        <div className="flex h-11 w-11 items-center justify-center rounded-full bg-primary-50">
+          <Logo size={32} noText />
+        </div>
+        <div>
+          <p className="flex items-center justify-center gap-1.5 font-serif text-lg tracking-tight text-gray-800">
+            Research assistant
+          </p>
+          <p className="mt-1.5 text-xs leading-relaxed text-gray-500">
+            Ask questions about this {noun}, search the web and scholarly literature, or have the
+            assistant edit the draft for you.
+          </p>
+        </div>
+      </div>
+      <ChatPresets
+        noteIsEmpty={noteIsEmpty}
+        isRfp={noteIsRfp}
+        onSelect={onSelectPreset}
+        disabled={presetsDisabled}
+      />
+    </div>
+  );
+}
diff --git a/components/AgentChat/ChatPicker.tsx b/components/AgentChat/ChatPicker.tsx
index ecfb439d8..e18b36814 100644
--- a/components/AgentChat/ChatPicker.tsx
+++ b/components/AgentChat/ChatPicker.tsx
@@ -1,12 +1,13 @@
 'use client';
 
 import type { ReactNode } from 'react';
-import { Loader } from '@/components/ui/Loader';
+import { SquarePen } from 'lucide-react';
 import { BaseMenu, BaseMenuItem } from '@/components/ui/form/BaseMenu';
 import { MenuTrigger } from '@/components/ui/MenuTrigger';
 import { cn } from '@/utils/styles';
 import { formatTimeAgo } from '@/utils/date';
 import type { AgentChatListItem } from '@/types/agentChat';
+import { AssistantActivityDot } from './AssistantActivityDot';
 
 interface ChatPickerProps {
   readonly chats: AgentChatListItem[];
@@ -22,14 +23,22 @@ interface ChatPickerProps {
    * is — it only owns where it sits.
    */
   readonly titleAction?: ReactNode;
+  /** What opens the menu, in place of the open chat's title. */
+  readonly trigger?: ReactNode;
+  /** Offers a new chat as the menu's first item. */
+  readonly onNewChat?: () => void;
+  /** The listing could not be loaded; the menu offers to try again. */
+  readonly failed?: boolean;
+  readonly className?: string;
 }
 
 /**
- * Header dropdown for switching between the note's chats. Built on the cheap
- * listing projection: title, preview, activity spinner — never full chats.
+ * A dropdown for switching between a document's chats. Built on the cheap
+ * listing projection: title, preview, activity dot — never full chats.
  *
- * Switching is all it does. Starting a chat lives on the header button beside
- * it, where it is one tap rather than two.
+ * In the notebook it is the header's title and switching is all it does;
+ * starting a chat lives on the header button beside it, where it is one tap
+ * rather than two. The workspace opens it from an icon, with "New chat" first.
  */
 export function ChatPicker({
   chats,
@@ -38,6 +47,10 @@ export function ChatPicker({
   onSelect,
   onOpen,
   titleAction,
+  trigger,
+  onNewChat,
+  failed = false,
+  className,
 }: ChatPickerProps) {
   const currentLabel = activeChatId == null ? 'New chat' : activeTitle?.trim() || 'Untitled chat';
 
@@ -46,22 +59,53 @@ export function ChatPicker({
     // nothing inside grows: the picker and the title action sit together at
     // the left and the slack collects after them. Only a title long enough to
     // need the space takes it, truncating rather than shoving.
-    <div className="flex min-w-0 flex-1 items-center">
+    <div className={cn('flex min-w-0 flex-1 items-center', className)}>
       <BaseMenu
-        align="start"
+        align={trigger ? 'end' : 'start'}
         className="w-[320px] max-w-[calc(100vw-1rem)] rounded-lg"
         onOpenChange={(open) => {
           if (open) onOpen();
         }}
         trigger={
-          <MenuTrigger srLabel="Chat:" className="text-sm text-gray-800">
-            {currentLabel}
-          </MenuTrigger>
+          trigger ?? (
+            <MenuTrigger srLabel="Chat:" className="text-sm text-gray-800">
+              {currentLabel}
+            </MenuTrigger>
+          )
         }
       >
+        {onNewChat && (
+          <>
+            <BaseMenuItem
+              onSelect={onNewChat}
+              className="cursor-pointer gap-2.5 rounded-md px-3 py-2 text-sm font-medium text-gray-900 focus:bg-gray-50 data-[highlighted]:bg-gray-50"
+            >
+              <SquarePen className="h-4 w-4 text-primary-600" aria-hidden="true" />
+              New chat
+            </BaseMenuItem>
+            {chats.length > 0 && (
+              <div aria-hidden="true" className="mx-1.5 my-1 h-px bg-gray-200" />
+            )}
+          </>
+        )}
+
+        {failed && chats.length === 0 && (
+          <BaseMenuItem
+            onSelect={(event) => {
+              // Stays open to show what the retry brings back.
+              event.preventDefault();
+              onOpen();
+            }}
+            className="cursor-pointer flex-col items-start gap-0.5 rounded-md px-3 py-2 focus:bg-gray-50 data-[highlighted]:bg-gray-50"
+          >
+            <span className="text-sm text-gray-600">Couldn’t load chats.</span>
+            <span className="text-xs font-medium text-primary-600">Try again</span>
+          </BaseMenuItem>
+        )}
+
         {/* The listing is empty until the first chat is saved, and the menu
             would otherwise open as a bare box. */}
-        {chats.length === 0 && (
+        {chats.length === 0 && !onNewChat && !failed && (
           <p className="px-3 py-2 text-sm text-gray-500">No chats on this note yet.</p>
         )}
 
@@ -83,7 +127,7 @@ export function ChatPicker({
                   {chat.title?.trim() || 'Untitled chat'}
                 </span>
                 {chat.has_active_turn && (
-                  <Loader size="sm" className="!h-3 !w-3 shrink-0 text-primary-500" />
+                  <AssistantActivityDot state="working" className="ml-auto shrink-0 pl-1" />
                 )}
               </div>
               {chat.last_message_preview && (
diff --git a/components/Funding/createFundingDraft.ts b/components/Funding/createFundingDraft.ts
new file mode 100644
index 000000000..d97d7dd7f
--- /dev/null
+++ b/components/Funding/createFundingDraft.ts
@@ -0,0 +1,74 @@
+import type { JSONContent } from '@tiptap/core';
+import { getTemplatePlainText } from '@/components/Editor/lib/utils/documentTitle';
+import { NoteService } from '@/services/note.service';
+import type { Note, NoteAccess } from '@/types/note';
+import type { ID } from '@/types/root';
+import type { FundingIntent } from './fundingDirection';
+
+/** The note's document type for each side of the money. */
+export const DOCUMENT_TYPE_BY_INTENT: Record<FundingIntent, string> = {
+  fund: 'GRANT',
+  need_funding: 'PREREGISTRATION',
+};
+
+export interface CreateFundingDraftOptions {
+  readonly orgSlug: string;
+  readonly title: string;
+  /** `GRANT`, `PREREGISTRATION`, or the notebook's changelog `DISCUSSION`. */
+  readonly documentType: string;
+  /** `WORKSPACE` shares it with the organization; `PRIVATE` keeps it to its author. */
+  readonly grouping: NoteAccess;
+  /** The Request for Proposals a proposal answers. */
+  readonly selectedGrantId?: Exclude<ID, null | undefined> | null;
+  /** What the document starts with; without one it starts empty. */
+  readonly template?: JSONContent;
+  /**
+   * A note an earlier attempt created before a later step failed: the
+   * creation resumes on it instead of making a second one.
+   */
+  readonly existingNote?: Note | null;
+  /** The note exists; runs before the later steps, so a caller can keep it for a retry. */
+  readonly onNoteCreated?: (note: Note) => void;
+}
+
+/**
+ * A new draft: the note, then the RFP it answers, then its first content.
+ * Shared by the notebook, which starts drafts from templates, and the
+ * workspace, which starts them empty for the assistant to write. Throws if
+ * any step fails; the steps after creation can be run again.
+ */
+export async function createFundingDraft({
+  orgSlug,
+  title,
+  documentType,
+  grouping,
+  selectedGrantId,
+  template,
+  existingNote,
+  onNoteCreated,
+}: CreateFundingDraftOptions): Promise<Note> {
+  let note = existingNote ?? null;
+  if (note == null) {
+    note = await NoteService.createNote({
+      title,
+      grouping,
+      organization_slug: orgSlug,
+      document_type: documentType,
+    });
+    onNoteCreated?.(note);
+  }
+
+  if (selectedGrantId) {
+    await NoteService.updateNote({ noteId: note.id, selectedGrantId });
+  }
+
+  if (template) {
+    await NoteService.updateNoteContent({
+      note: note.id,
+      full_json: JSON.stringify(template),
+      plain_text: getTemplatePlainText(template),
+    });
+  }
+
+  return note;
+}
diff --git a/components/Funding/dashboard/DraftCarousel.tsx b/components/Funding/dashboard/DraftCarousel.tsx
index 63ef02adf..29ad6ff25 100644
--- a/components/Funding/dashboard/DraftCarousel.tsx
+++ b/components/Funding/dashboard/DraftCarousel.tsx
@@ -14,13 +14,14 @@ import { BaseModal } from '@/components/ui/BaseModal';
 import { Button } from '@/components/ui/Button';
 import { Carousel } from '@/components/ui/Carousel';
 import { BaseMenu, BaseMenuItem } from '@/components/ui/form/BaseMenu';
+import { useFundingDocuments } from '@/contexts/FundingDocumentsContext';
 import { NoteService } from '@/services/note.service';
 
 interface DraftCarouselProps {
   /** The latest edit first. */
   readonly drafts: DraftDocument[];
-  /** Read the drafts again, once one has been deleted. */
-  readonly onDeleted: () => Promise<void>;
+  /** How many drafts there are, which can be more than are loaded. */
+  readonly count: number;
 }
 
 /**
@@ -29,8 +30,9 @@ interface DraftCarouselProps {
  * A draft's card is dashed, still being drawn; it opens where the user
  * drafts, and can be deleted from the menu in its corner.
  */
-export function DraftCarousel({ drafts, onDeleted }: DraftCarouselProps) {
+export function DraftCarousel({ drafts, count }: DraftCarouselProps) {
   const { openDraft } = useFundingDrafting();
+  const { remove } = useFundingDocuments();
 
   // ---- deleting a draft, behind a confirmation ----
   const [deleting, setDeleting] = useState<DraftDocument | null>(null);
@@ -41,19 +43,19 @@ export function DraftCarousel({ drafts, onDeleted }: DraftCarouselProps) {
     try {
       await NoteService.deleteNote(deleting.note.id);
       setDeleting(null);
-      await onDeleted();
+      remove(deleting.note.id);
     } catch {
       toast.error('Couldn’t delete the draft. Please try again.');
     } finally {
       setIsDeleting(false);
     }
-  }, [deleting, onDeleted]);
+  }, [deleting, remove]);
 
   return (
     <section>
       <DashboardSectionHeader
         title="Continue where you left off"
-        meta={`${drafts.length} ${drafts.length === 1 ? 'draft' : 'drafts'}`}
+        meta={`${count} ${count === 1 ? 'draft' : 'drafts'}`}
       />
 
       {/* The carousel pads its own track; the margin takes that back from the heading. */}
diff --git a/components/Funding/dashboard/hooks/useMyFundingDocuments.ts b/components/Funding/dashboard/hooks/useMyFundingDocuments.ts
index 060209c1a..a8bd2e542 100644
--- a/components/Funding/dashboard/hooks/useMyFundingDocuments.ts
+++ b/components/Funding/dashboard/hooks/useMyFundingDocuments.ts
@@ -1,12 +1,11 @@
 'use client';
 
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useOrganizationContext } from '@/contexts/OrganizationContext';
+import { useFundingDocuments } from '@/contexts/FundingDocumentsContext';
 import { useFeed } from '@/hooks/useFeed';
-import { useOrganizationNotes } from '@/hooks/useOrganizationNotes';
 import { FUNDING_KIND_LABEL, type FundingKind } from '@/components/Funding/fundingKind';
 import type { FeedEntry, FeedGrantContent, FeedPostContent } from '@/types/feed';
-import { getNoteKind, isPublishedNote, type Note, type NoteKind } from '@/types/note';
+import { getNoteKind, type Note, type NoteKind } from '@/types/note';
 import { formatTimeAgo } from '@/utils/date';
 import { buildWorkUrl } from '@/utils/url';
 
@@ -115,6 +114,8 @@ const draftDocument = (note: Note, kind: FundingKind): DraftDocument => ({
   note,
 });
 
+const DRAFTS_ERROR = new Error('Couldn’t load your drafts.');
+
 const isFundingKind = (kind: NoteKind): kind is FundingKind =>
   kind === 'rfp' || kind === 'proposal';
 
@@ -134,6 +135,8 @@ export interface MyFundingDocuments {
   readonly published: PublishedDocument[];
   /** Unpublished RFPs and proposals, the latest edit first. */
   readonly drafts: DraftDocument[];
+  /** How many drafts there are, which can be more than are loaded. */
+  readonly draftCount: number;
   /**
    * Both feeds and the notes have finished their first load. Each arrives at
    * its own pace, and showing one before the others would lay the page out
@@ -144,8 +147,6 @@ export interface MyFundingDocuments {
   /** Either feed has another page. */
   readonly hasMore: boolean;
   readonly loadMore: () => void;
-  /** Read the notes again, after a draft is deleted. */
-  readonly refreshDrafts: () => Promise<void>;
 }
 
 /**
@@ -159,7 +160,8 @@ export function useMyFundingDocuments({
   viewedUserId,
   isOwnPage,
 }: UseMyFundingDocumentsOptions): MyFundingDocuments {
-  const { selectedOrg, isLoading: isLoadingOrg } = useOrganizationContext();
+  // The user's own drafts, as the sidebar lists them.
+  const ownDocuments = useFundingDocuments();
 
   const rfpFeedOptions = useMemo(
     () => ({ endpoint: 'grant_feed' as const, contentType: 'GRANT', createdBy: viewedUserId }),
@@ -177,14 +179,12 @@ export function useMyFundingDocuments({
   );
   const rfpFeed = useFeed('all', rfpFeedOptions);
   const proposalFeed = useFeed('all', proposalFeedOptions);
-  const notes = useOrganizationNotes(isOwnPage ? selectedOrg?.slug : null, {
-    waiting: isOwnPage && isLoadingOrg,
-  });
+  const notesLoading = ownDocuments.status === 'loading';
+  const notesError = ownDocuments.status === 'error' ? DRAFTS_ERROR : null;
 
   // A feed that is switched off never leaves its loading state, so only the
   // sources this page reads are waited for.
-  const loadingFirst =
-    rfpFeed.isLoading || (isOwnPage && (proposalFeed.isLoading || notes.isLoading));
+  const loadingFirst = rfpFeed.isLoading || (isOwnPage && (proposalFeed.isLoading || notesLoading));
   const [isSettled, setIsSettled] = useState(false);
   useEffect(() => {
     if (!loadingFirst) setIsSettled(true);
@@ -204,20 +204,14 @@ export function useMyFundingDocuments({
 
   const drafts = useMemo<DraftDocument[]>(() => {
     if (!isOwnPage) return [];
-    return notes.notes
-      .filter((note) => !note.isRemoved && !isPublishedNote(note))
-      .sort((a, b) => new Date(b.updatedDate).getTime() - new Date(a.updatedDate).getTime())
-      .flatMap((note) => {
-        const kind = getNoteKind(note);
-        return isFundingKind(kind) ? [draftDocument(note, kind)] : [];
-      });
-  }, [isOwnPage, notes.notes]);
+    return ownDocuments.drafts.flatMap((note) => {
+      const kind = getNoteKind(note);
+      return isFundingKind(kind) ? [draftDocument(note, kind)] : [];
+    });
+  }, [isOwnPage, ownDocuments.drafts]);
 
   const proposalsHaveMore = isOwnPage && proposalFeed.hasMore;
-  const error = rfpFeed.error ?? (isOwnPage ? (proposalFeed.error ?? notes.error) : null);
-  useEffect(() => {
-    if (notes.error) console.error('Failed to load My Funding drafts:', notes.error);
-  }, [notes.error]);
+  const error = rfpFeed.error ?? (isOwnPage ? (proposalFeed.error ?? notesError) : null);
   const loadMore = useCallback(() => {
     if (rfpFeed.hasMore) rfpFeed.loadMore();
     if (proposalsHaveMore) proposalFeed.loadMore();
@@ -226,10 +220,10 @@ export function useMyFundingDocuments({
   return {
     published,
     drafts,
+    draftCount: isOwnPage ? ownDocuments.draftCount : 0,
     isSettled,
     error,
     hasMore: rfpFeed.hasMore || proposalsHaveMore,
     loadMore,
-    refreshDrafts: notes.refresh,
   };
 }
diff --git a/components/Funding/fundingDraftOptions.tsx b/components/Funding/fundingDraftOptions.tsx
new file mode 100644
index 000000000..47ddb2114
--- /dev/null
+++ b/components/Funding/fundingDraftOptions.tsx
@@ -0,0 +1,81 @@
+'use client';
+
+import type { ReactNode } from 'react';
+import { ChevronRight } from 'lucide-react';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { BaseMenuItem } from '@/components/ui/form/BaseMenu';
+import { FUNDING_KIND_ICON } from './fundingKind';
+import type { FundingIntent } from './fundingDirection';
+
+export interface FundingDraftOption {
+  readonly id: string;
+  readonly title: string;
+  readonly description: string;
+  readonly icon: ReactNode;
+  /** Which side of the money the option starts: an RFP funds, a proposal needs funding. */
+  readonly intent: FundingIntent;
+}
+
+/** The two things a user can start drafting: wherever a new draft is offered, these are the choices. */
+export const FUNDING_DRAFT_OPTIONS: readonly FundingDraftOption[] = [
+  {
+    id: 'give-funding',
+    title: 'Request for Proposal',
+    description: 'Fund specific research you care about',
+    icon: (
+      <FontAwesomeIcon icon={FUNDING_KIND_ICON.rfp} className="h-[18px] w-[18px] text-gray-700" />
+    ),
+    intent: 'fund',
+  },
+  {
+    id: 'request-funding',
+    title: 'Proposal',
+    description: 'Raise money for your research',
+    icon: (
+      <FontAwesomeIcon
+        icon={FUNDING_KIND_ICON.proposal}
+        className="h-[18px] w-[18px] text-gray-700"
+      />
+    ),
+    intent: 'need_funding',
+  },
+];
+
+/** One option's face: its icon in a tile, its name and what it is for. */
+export function FundingDraftOptionContent({ option }: { readonly option: FundingDraftOption }) {
+  return (
+    <div className="relative flex w-full items-center gap-3 pr-6">
+      <div className="flex-shrink-0">
+        <div className="flex h-9 w-9 items-center justify-center rounded-lg bg-gray-100 transition-colors duration-150 group-hover:bg-gray-50">
+          {option.icon}
+        </div>
+      </div>
+      <div className="min-w-0 flex-1">
+        <div className="text-sm font-semibold tracking-[0.01em] text-gray-900">{option.title}</div>
+        <div className="text-xs text-gray-600">{option.description}</div>
+      </div>
+      <ChevronRight className="absolute right-0 top-1/2 h-4 w-4 -translate-y-1/2 text-gray-900 opacity-0 transition-opacity duration-200 group-hover:opacity-100" />
+    </div>
+  );
+}
+
+/** The options as items of a `BaseMenu`. */
+export function FundingDraftMenuItems({
+  onSelect,
+}: {
+  readonly onSelect: (option: FundingDraftOption) => void;
+}) {
+  return (
+    <div className="space-y-1">
+      {FUNDING_DRAFT_OPTIONS.map((option) => (
+        <BaseMenuItem
+          key={option.id}
+          onClick={() => onSelect(option)}
+          className="group w-full cursor-pointer rounded-lg px-2 py-2 transition-colors duration-150 hover:bg-gray-100 focus:bg-gray-100"
+        >
+          <FundingDraftOptionContent option={option} />
+        </BaseMenuItem>
+      ))}
+    </div>
+  );
+}
diff --git a/components/Funding/useFundingDrafting.ts b/components/Funding/useFundingDrafting.ts
index d7a3f2f4c..4a1ffe5ac 100644
--- a/components/Funding/useFundingDrafting.ts
+++ b/components/Funding/useFundingDrafting.ts
@@ -5,37 +5,30 @@ import { useRouter } from 'next/navigation';
 import { useOptionalAIMode } from '@/components/AIMode/AIModeContext';
 import {
   documentTarget,
-  newConversationTarget,
+  newDraftTarget,
   workspaceHref,
   type WorkspaceTarget,
 } from '@/components/AIMode/workspaceUrl';
-import { useUser } from '@/contexts/UserContext';
 import type { Note } from '@/types/note';
-import { isHubEditorOrModerator } from '@/utils/permissions';
 import type { FundingIntent } from './fundingDirection';
 
 export interface FundingDrafting {
-  /** This user drafts in the workspace; everyone else still has the notebook editor. */
-  readonly inWorkspace: boolean;
   /** Start a new RFP (`fund`) or proposal (`need_funding`). */
   readonly startNew: (intent: FundingIntent) => void;
-  /** Pick a draft back up. */
-  readonly openDraft: (note: Pick<Note, 'id' | 'organization'>) => void;
+  /** Pick a draft back up, or open a published document. */
+  readonly openDraft: (note: Pick<Note, 'id'>) => void;
 }
 
 /**
- * Where drafting happens for this user: the workspace page, for the
- * moderators and hub editors it admits, or the notebook editor for everyone
- * else. One answer for every door — the Publish menu, the New RFP and New
- * proposal buttons on My Funding, a draft's row.
+ * Drafting happens in the workspace. One answer for every door — the Publish
+ * menu, the Drafts "+" in the sidebar, My Funding's New RFP and New proposal
+ * buttons, a document's row.
  */
 export function useFundingDrafting(): FundingDrafting {
   const router = useRouter();
   // Non-null only on the workspace page itself, where a door changes what is
   // open in place rather than navigating to where it already is.
   const openWorkspace = useOptionalAIMode();
-  const { user } = useUser();
-  const inWorkspace = isHubEditorOrModerator(user);
 
   return useMemo(() => {
     const goTo = (target: WorkspaceTarget) => {
@@ -43,16 +36,8 @@ export function useFundingDrafting(): FundingDrafting {
       else router.push(workspaceHref(target));
     };
     return {
-      inWorkspace,
-      startNew: (intent) => {
-        if (inWorkspace) goTo(newConversationTarget(intent));
-        else
-          router.push(intent === 'fund' ? '/notebook?newGrant=true' : '/notebook?newFunding=true');
-      },
-      openDraft: (note) => {
-        if (inWorkspace) goTo(documentTarget(note.id));
-        else router.push(`/notebook/${note.organization.slug}/${note.id}`);
-      },
+      startNew: (intent) => goTo(newDraftTarget(intent)),
+      openDraft: (note) => goTo(documentTarget(note.id)),
     };
-  }, [inWorkspace, openWorkspace, router]);
+  }, [openWorkspace, router]);
 }
diff --git a/components/Notebook/AgentChatPanel.tsx b/components/Notebook/AgentChatPanel.tsx
index 80072315e..f84f3d7cd 100644
--- a/components/Notebook/AgentChatPanel.tsx
+++ b/components/Notebook/AgentChatPanel.tsx
@@ -23,13 +23,12 @@ import { useNoteAgentReview } from '@/components/Notebook/NoteReview/useNoteAgen
 import { ChatComposer } from '@/components/AgentChat/ChatComposer';
 import type { ChatNoticePolicy } from '@/components/AgentChat/chatNotices';
 import { ChatPicker } from '@/components/AgentChat/ChatPicker';
-import { ChatPresets } from '@/components/AgentChat/ChatPresets';
+import { ChatEmptyState } from '@/components/AgentChat/ChatEmptyState';
 import { ChatSources, collectChatSources } from '@/components/AgentChat/ChatSources';
 import { ChatTranscript } from '@/components/AgentChat/ChatTranscript';
 import { CreditMeter } from '@/components/AgentChat/CreditMeter';
 import { canSelectAIModel } from '@/types/researchAI';
 import { ModelControls } from '@/components/AgentChat/ModelControls';
-import { Logo } from '@/components/ui/Logo';
 
 type PanelTab = 'chat' | 'sources';
 
@@ -302,7 +301,7 @@ export function AgentChatPanel({
   const composerDisabled = accessDenied || !chatAccessible;
 
   const emptyState = (
-    <EmptyState
+    <ChatEmptyState
       noteIsEmpty={noteIsEmpty}
       noteIsRfp={noteIsRfp}
       onSelectPreset={applyPreset}
@@ -653,40 +652,3 @@ function ErrorState({
     </div>
   );
 }
-
-function EmptyState({
-  noteIsEmpty,
-  noteIsRfp,
-  onSelectPreset,
-  presetsDisabled,
-}: {
-  readonly noteIsEmpty: boolean;
-  readonly noteIsRfp: boolean;
-  readonly onSelectPreset: (message: string) => void;
-  readonly presetsDisabled: boolean;
-}) {
-  return (
-    <div className="flex h-full flex-col items-center justify-center gap-5 px-6 text-center">
-      <div className="flex flex-col items-center gap-3">
-        <div className="flex h-11 w-11 items-center justify-center rounded-full bg-primary-50">
-          <Logo size={32} noText />
-        </div>
-        <div>
-          <p className="flex items-center justify-center gap-1.5 font-serif text-lg tracking-tight text-gray-800">
-            Research assistant
-          </p>
-          <p className="mt-1.5 text-xs leading-relaxed text-gray-500">
-            Ask questions about this note, search the web and scholarly literature, or have the
-            assistant edit the draft for you.
-          </p>
-        </div>
-      </div>
-      <ChatPresets
-        noteIsEmpty={noteIsEmpty}
-        isRfp={noteIsRfp}
-        onSelect={onSelectPreset}
-        disabled={presetsDisabled}
-      />
-    </div>
-  );
-}
diff --git a/components/Notebook/PublishingForm/PublishingFormProvider.tsx b/components/Notebook/PublishingForm/PublishingFormProvider.tsx
index a76480058..9f942f325 100644
--- a/components/Notebook/PublishingForm/PublishingFormProvider.tsx
+++ b/components/Notebook/PublishingForm/PublishingFormProvider.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import { createContext, useContext, useEffect, type ReactNode } from 'react';
+import { createContext, useContext, useEffect, useRef, type ReactNode } from 'react';
 import { useSearchParams } from 'next/navigation';
 import type { Editor } from '@tiptap/react';
 import { FormProvider, useForm } from 'react-hook-form';
@@ -69,9 +69,26 @@ interface PublishingFormProviderProps {
    * what is still missing, and is where a nonprofit is chosen and confirmed.
    */
   readonly publishConfirmation?: ReactNode;
+  /**
+   * The note as the server has it now, fetched again after something other
+   * than this form changed it (the assistant filling in an RFP's details).
+   * The details that changed there since the form loaded are applied to the
+   * form; nothing is saved back, and fields the server did not change keep
+   * whatever the user has typed.
+   */
+  readonly refreshedNote?: NoteWithContent | null;
   readonly children: ReactNode;
 }
 
+/** The form values a note's saved details fill in, by field. */
+function noteDetailValues(note: NoteWithContent): Map<string, unknown> {
+  const values = new Map<string, unknown>();
+  populateFormFromNoteDetails(note, (name: string, value: unknown) => {
+    values.set(name, value);
+  });
+  return values;
+}
+
 /**
  * Owns the publishing form for the note the host provides: its values, how
  * they load from the note and save back to it, and the publish flow. Anything
@@ -83,6 +100,7 @@ export function PublishingFormProvider({
   readOnly = false,
   publishTitle,
   publishConfirmation,
+  refreshedNote,
   children,
 }: PublishingFormProviderProps) {
   const { note, editor, saveDetailsSoon, saveDetailsNow } = usePublishingHost();
@@ -97,10 +115,15 @@ export function PublishingFormProvider({
 
   const noteId = note?.id;
   const isPublished = Boolean(note?.post);
+  // The details as last read from the server, and whether the form is being
+  // brought up to date with them (which is not the user's edit to save).
+  const serverDetailsRef = useRef<Map<string, unknown> | null>(null);
+  const applyingServerRef = useRef(false);
 
   useEffect(() => {
     if (!note) return;
 
+    serverDetailsRef.current = noteDetailValues(note);
     methods.reset(FORM_DEFAULTS);
     const isRegisteredReport = isRegisteredReportNote(note);
 
@@ -148,7 +171,7 @@ export function PublishingFormProvider({
     if (!noteId || isPublished) return;
 
     const subscription = methods.watch((_values, { name }) => {
-      if (!name) return;
+      if (!name || applyingServerRef.current) return;
 
       const values = methods.getValues();
       if (name === 'selectedNonprofit') {
@@ -163,6 +186,22 @@ export function PublishingFormProvider({
     return () => subscription.unsubscribe();
   }, [noteId, isPublished, methods, saveDetailsSoon]);
 
+  useEffect(() => {
+    if (!refreshedNote || refreshedNote.id !== noteId || isPublished) return;
+    const next = noteDetailValues(refreshedNote);
+    const before = serverDetailsRef.current ?? new Map<string, unknown>();
+    applyingServerRef.current = true;
+    try {
+      next.forEach((value, name) => {
+        if (JSON.stringify(before.get(name)) === JSON.stringify(value)) return;
+        methods.setValue(name as keyof PublishingFormData, value as never);
+      });
+    } finally {
+      applyingServerRef.current = false;
+    }
+    serverDetailsRef.current = next;
+  }, [refreshedNote, noteId, isPublished, methods]);
+
   const { watch, clearErrors } = methods;
   const articleType = watch('articleType');
   const workId = watch('workId');
diff --git a/components/Notebook/PublishingForm/usePublishAction.ts b/components/Notebook/PublishingForm/usePublishAction.ts
index af06ea78e..fea665478 100644
--- a/components/Notebook/PublishingForm/usePublishAction.ts
+++ b/components/Notebook/PublishingForm/usePublishAction.ts
@@ -4,6 +4,7 @@ import type { Editor } from '@tiptap/react';
 import type { UseFormReturn } from 'react-hook-form';
 import { toast } from 'react-hot-toast';
 import { setDocumentTitle } from '@/components/Editor/lib/utils/documentTitle';
+import { useFundingDocuments } from '@/contexts/FundingDocumentsContext';
 import { useAssetUpload } from '@/hooks/useAssetUpload';
 import { useUpsertPost } from '@/hooks/useDocument';
 import { useNonprofitLink } from '@/hooks/useNonprofitLink';
@@ -97,6 +98,7 @@ export function usePublishAction({
   const [{ loading: isUploadingImage }, uploadAsset] = useAssetUpload();
   const [{ isLoading: isLoadingUpsert }, upsertPost] = useUpsertPost();
   const { linkNonprofitToFundraise, isLoading: isLinkingNonprofit } = useNonprofitLink();
+  const { refresh: refreshFundingDocuments } = useFundingDocuments();
 
   const dismissConfirmation = useCallback(() => setPendingConfirmation(null), []);
   const acceptNonprofit = useCallback(() => setPendingConfirmation('publish'), []);
@@ -351,6 +353,8 @@ export function usePublishAction({
         } else {
           toast.success(`${publishLabel} published successfully!`);
         }
+        // The document has a post now: the sidebar moves it from Drafts to Published.
+        void refreshFundingDocuments();
         router.push(getWorkPath(formData.articleType, String(response.id), response.slug));
       } catch (error: unknown) {
         const fallback = 'Error publishing. Please try again.';
@@ -387,6 +391,7 @@ export function usePublishAction({
       upsertPost,
       tryLinkNonprofit,
       isChangelog,
+      refreshFundingDocuments,
       router,
     ]
   );
diff --git a/components/providers/ClientProviders.tsx b/components/providers/ClientProviders.tsx
index 74547835d..a246eca42 100644
--- a/components/providers/ClientProviders.tsx
+++ b/components/providers/ClientProviders.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import { ReactNode, Suspense } from 'react';
+import { ReactNode } from 'react';
 import { Session } from 'next-auth';
 import NextAuthProvider from '@/components/providers/NextAuthProvider';
 import ToasterProvider from '@/components/providers/ToasterProvider';
@@ -26,7 +26,7 @@ import { UserListsProvider } from '@/components/UserList/lib/UserListsContext';
 import { LeaderboardProvider } from '@/contexts/LeaderboardContext';
 import { DismissedFeaturesProvider } from '@/contexts/DismissedFeaturesContext';
 import { PendingCountsProvider } from '@/components/Moderators/PendingCountsContext';
-import { LegacyAIModeRedirect } from '@/components/AIMode/LegacyAIModeRedirect';
+import { FundingDocumentsProvider } from '@/contexts/FundingDocumentsContext';
 
 interface ClientProvidersProps {
   readonly children: ReactNode;
@@ -56,19 +56,19 @@ export function ClientProviders({ children, session }: ClientProvidersProps) {
                                 <FundingPowerProvider>
                                   <NotificationProvider>
                                     <OrganizationProvider>
-                                      <UserListsProvider>
-                                        <LeaderboardProvider>
-                                          <DismissedFeaturesProvider>
-                                            <FollowProvider>{children}</FollowProvider>
-                                            {/* Behind Suspense: it reads the URL's
-                                                search params. */}
-                                            <Suspense fallback={null}>
-                                              <LegacyAIModeRedirect />
-                                            </Suspense>
-                                            <FeatureNotifications />
-                                          </DismissedFeaturesProvider>
-                                        </LeaderboardProvider>
-                                      </UserListsProvider>
+                                      {/* Above the layouts: every page's left
+                                          sidebar lists these documents, and
+                                          navigating must not fetch them again. */}
+                                      <FundingDocumentsProvider>
+                                        <UserListsProvider>
+                                          <LeaderboardProvider>
+                                            <DismissedFeaturesProvider>
+                                              <FollowProvider>{children}</FollowProvider>
+                                              <FeatureNotifications />
+                                            </DismissedFeaturesProvider>
+                                          </LeaderboardProvider>
+                                        </UserListsProvider>
+                                      </FundingDocumentsProvider>
                                     </OrganizationProvider>
                                   </NotificationProvider>
                                 </FundingPowerProvider>
diff --git a/components/skeletons/AIModeSkeleton.tsx b/components/skeletons/AIModeSkeleton.tsx
index 1033bd7e1..60b239a8a 100644
--- a/components/skeletons/AIModeSkeleton.tsx
+++ b/components/skeletons/AIModeSkeleton.tsx
@@ -1,21 +1,5 @@
 import React from 'react';
 
-/** Placeholder rows for the AI Mode conversation list: a title and a timestamp. */
-export const ConversationListSkeleton: React.FC<{ count?: number }> = ({ count = 6 }) => (
-  // One step darker than the other skeletons: the list sits on gray-100.
-  <div className="space-y-1 px-1" aria-hidden="true">
-    {Array.from({ length: count }).map((_, index) => (
-      <div key={index} className="space-y-1.5 px-3 py-2">
-        <div
-          className="h-3.5 animate-pulse rounded bg-gray-200"
-          style={{ width: `${70 + ((index * 17) % 25)}%` }}
-        />
-        <div className="h-2.5 w-16 animate-pulse rounded bg-gray-200" />
-      </div>
-    ))}
-  </div>
-);
-
 /** Placeholder transcript: a user bubble on the right, an answer on the left. */
 export const ChatTranscriptSkeleton: React.FC = () => (
   <div className="space-y-6" aria-hidden="true">
diff --git a/contexts/FundingDocumentsContext.tsx b/contexts/FundingDocumentsContext.tsx
new file mode 100644
index 000000000..5620eccae
--- /dev/null
+++ b/contexts/FundingDocumentsContext.tsx
@@ -0,0 +1,229 @@
+'use client';
+
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type ReactNode,
+} from 'react';
+import { useOrganizationContext } from '@/contexts/OrganizationContext';
+import { useUser } from '@/contexts/UserContext';
+import { NoteService, type GetOrganizationNotesParams } from '@/services/note.service';
+import type { Note } from '@/types/note';
+import type { ID } from '@/types/root';
+
+export type FundingDocumentsStatus = 'off' | 'loading' | 'ready' | 'error';
+
+export interface FundingDocuments {
+  /** RFPs and proposals without a post, latest edit first. */
+  readonly drafts: readonly Note[];
+  /** RFPs and proposals with a post, open or inactive, latest edit first. */
+  readonly published: readonly Note[];
+  /** How many drafts the server has, which can be more than are loaded. */
+  readonly draftCount: number;
+  /** `off` until there is a signed-in user with an organization; `loading` only before the first load. */
+  readonly status: FundingDocumentsStatus;
+  /** Load both lists again: after "Try again", or once something was published. */
+  readonly refresh: () => Promise<void>;
+  /** A draft just created here; it leads the list at once. */
+  readonly addDraft: (note: Note) => void;
+  /** A document changed here: its row says so at once. */
+  readonly patch: (noteId: ID, changes: Partial<Pick<Note, 'title' | 'updatedDate'>>) => void;
+  /** A document deleted here: its row goes at once. */
+  readonly remove: (noteId: ID) => void;
+}
+
+const noop = () => {};
+
+const OFF: FundingDocuments = {
+  drafts: [],
+  published: [],
+  draftCount: 0,
+  status: 'off',
+  refresh: async () => {},
+  addDraft: noop,
+  patch: noop,
+  remove: noop,
+};
+
+const FundingDocumentsContext = createContext<FundingDocuments>(OFF);
+
+/** The two kinds of document the funding side drafts and publishes. */
+const FUNDING_DOCUMENT_TYPES = ['PREREGISTRATION', 'GRANT'] as const;
+
+interface DocumentLists {
+  /** Whose lists these are: `user:organization`. */
+  readonly key: string | null;
+  readonly drafts: Note[];
+  readonly published: Note[];
+  readonly draftCount: number;
+}
+
+const EMPTY: DocumentLists = { key: null, drafts: [], published: [], draftCount: 0 };
+
+const byLatestEdit = (a: Note, b: Note) =>
+  new Date(b.updatedDate).getTime() - new Date(a.updatedDate).getTime();
+
+/**
+ * One status's documents of both types. The listing filters by one type at a
+ * time, so each type is its own request and the two are merged here.
+ */
+async function loadDocuments(
+  orgSlug: string,
+  status: NonNullable<GetOrganizationNotesParams['status']>
+): Promise<{ notes: Note[]; count: number }> {
+  const pages = await Promise.all(
+    FUNDING_DOCUMENT_TYPES.map((documentType) =>
+      NoteService.getOrganizationNotes(orgSlug, { status, documentType, ordering: '-updated_date' })
+    )
+  );
+  const byId = new Map(pages.flatMap((page) => page.results).map((note) => [note.id, note]));
+  return {
+    notes: Array.from(byId.values())
+      .filter((note) => !note.isRemoved)
+      .sort(byLatestEdit),
+    count: pages.reduce((total, page) => total + page.count, 0),
+  };
+}
+
+/**
+ * The user's RFPs and proposals, drafts and published, loaded once for the
+ * whole app: the sidebar shows them on every page and My Funding lists the
+ * drafts, and moving between pages never fetches them again. Reloads when the
+ * user or the organization changes, and when asked to.
+ */
+export function FundingDocumentsProvider({ children }: { readonly children: ReactNode }) {
+  const { user } = useUser();
+  const { selectedOrg, isLoading: isLoadingOrg } = useOrganizationContext();
+  const userId = user?.id ?? null;
+  const orgSlug = selectedOrg?.slug ?? null;
+  const key = userId != null && orgSlug != null ? `${userId}:${orgSlug}` : null;
+
+  const [loaded, setLoaded] = useState<DocumentLists>(EMPTY);
+  // The first load for this key failed; a reload that fails keeps what it had.
+  const [failedKey, setFailedKey] = useState<string | null>(null);
+  // Only the latest load may land: a slower, older one would put back what
+  // a newer one replaced, or another user's documents.
+  const seqRef = useRef(0);
+
+  const load = useCallback(async (slug: string, forKey: string) => {
+    const seq = ++seqRef.current;
+    try {
+      const [drafts, published] = await Promise.all([
+        loadDocuments(slug, 'DRAFT'),
+        loadDocuments(slug, 'PUBLISHED'),
+      ]);
+      if (seq !== seqRef.current) return;
+      setLoaded({
+        key: forKey,
+        drafts: drafts.notes,
+        published: published.notes,
+        draftCount: drafts.count,
+      });
+      setFailedKey(null);
+    } catch (error) {
+      if (seq !== seqRef.current) return;
+      console.error('Failed to load funding documents:', error);
+      setFailedKey(forKey);
+    }
+  }, []);
+
+  useEffect(() => {
+    if (key == null || orgSlug == null) {
+      seqRef.current += 1;
+      return;
+    }
+    void load(orgSlug, key);
+    // The key already says which organization.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [key, load]);
+
+  const lists = loaded.key === key ? loaded : EMPTY;
+  const status: FundingDocumentsStatus =
+    key == null
+      ? userId != null && isLoadingOrg
+        ? 'loading'
+        : 'off'
+      : loaded.key === key
+        ? 'ready'
+        : failedKey === key
+          ? 'error'
+          : 'loading';
+
+  const refresh = useCallback(async () => {
+    if (key == null || orgSlug == null) return;
+    setFailedKey(null);
+    await load(orgSlug, key);
+  }, [key, orgSlug, load]);
+
+  const addDraft = useCallback((note: Note) => {
+    setLoaded((current) => {
+      const known = current.drafts.some((draft) => draft.id === note.id);
+      return {
+        ...current,
+        drafts: [note, ...current.drafts.filter((draft) => draft.id !== note.id)],
+        draftCount: current.draftCount + (known ? 0 : 1),
+      };
+    });
+  }, []);
+
+  const patch = useCallback((noteId: ID, changes: Partial<Pick<Note, 'title' | 'updatedDate'>>) => {
+    const update = (notes: Note[]) => {
+      const target = notes.find((note) => note.id === noteId);
+      const changed =
+        target != null &&
+        Object.entries(changes).some(
+          ([field, value]) => target[field as keyof typeof changes] !== value
+        );
+      if (!changed) return notes;
+      const next = notes.map((note) => (note.id === noteId ? { ...note, ...changes } : note));
+      return changes.updatedDate ? next.sort(byLatestEdit) : next;
+    };
+    setLoaded((current) => {
+      const drafts = update(current.drafts);
+      const published = update(current.published);
+      return drafts === current.drafts && published === current.published
+        ? current
+        : { ...current, drafts, published };
+    });
+  }, []);
+
+  const remove = useCallback((noteId: ID) => {
+    setLoaded((current) => {
+      const wasDraft = current.drafts.some((note) => note.id === noteId);
+      return {
+        ...current,
+        drafts: current.drafts.filter((note) => note.id !== noteId),
+        published: current.published.filter((note) => note.id !== noteId),
+        draftCount: Math.max(0, current.draftCount - (wasDraft ? 1 : 0)),
+      };
+    });
+  }, []);
+
+  const value = useMemo<FundingDocuments>(
+    () => ({
+      drafts: lists.drafts,
+      published: lists.published,
+      draftCount: lists.draftCount,
+      status,
+      refresh,
+      addDraft,
+      patch,
+      remove,
+    }),
+    [lists, status, refresh, addDraft, patch, remove]
+  );
+
+  return (
+    <FundingDocumentsContext.Provider value={value}>{children}</FundingDocumentsContext.Provider>
+  );
+}
+
+/** The user's RFPs and proposals; switched off (and empty) outside the provider. */
+export function useFundingDocuments(): FundingDocuments {
+  return useContext(FundingDocumentsContext);
+}
diff --git a/hooks/useAgentChat.ts b/hooks/useAgentChat.ts
index 55cd37d91..38ce63c6b 100644
--- a/hooks/useAgentChat.ts
+++ b/hooks/useAgentChat.ts
@@ -612,6 +612,11 @@ export type ChatListAccess = 'loading' | 'ok' | 'hidden' | 'error';
 export interface UseAgentChatListResult {
   chats: AgentChatListItem[];
   access: ChatListAccess;
+  /**
+   * The transport whose listing `chats` is: right after the transport
+   * changes, for one render, the previous one's rows are still here.
+   */
+  scopeKey: string | null;
   /** The server's `detail` copy behind a `hidden` or `error` access state. */
   accessDetail: string | null;
   refresh: () => Promise<void>;
@@ -630,6 +635,7 @@ export function useAgentChatList(
   const [chats, setChats] = useState<AgentChatListItem[]>([]);
   const [access, setAccess] = useState<ChatListAccess>('loading');
   const [accessDetail, setAccessDetail] = useState<string | null>(null);
+  const [scopeKey, setScopeKey] = useState<string | null>(null);
   const seqRef = useRef(0);
   // Same stale-continuation guard as the chat hook: a createChat bound to a
   // previous note must not refresh (or hide) the current note's listing.
@@ -642,6 +648,7 @@ export function useAgentChatList(
       const items = await transport.listChats();
       if (seq !== seqRef.current) return;
       setChats(items);
+      setScopeKey(transport.key);
       setAccess('ok');
       setAccessDetail(null);
     } catch (err) {
@@ -660,6 +667,7 @@ export function useAgentChatList(
     seqRef.current += 1;
     epochRef.current += 1;
     setChats([]);
+    setScopeKey(null);
     setAccess('loading');
     setAccessDetail(null);
     if (enabled && transport != null) {
@@ -686,5 +694,5 @@ export function useAgentChatList(
     [transport, refresh]
   );
 
-  return { chats, access, accessDetail, refresh, createChat };
+  return { chats, access, scopeKey, accessDetail, refresh, createChat };
 }
diff --git a/hooks/useChatAttachments.ts b/hooks/useChatAttachments.ts
index 57ec8bcf8..0e97aac03 100644
--- a/hooks/useChatAttachments.ts
+++ b/hooks/useChatAttachments.ts
@@ -68,8 +68,11 @@ export interface ChatAttachments {
   readonly makeRoom: () => void;
   /** Take the ready files for a send; they leave the composer until `settle`. */
   readonly hold: () => HeldAttachments;
-  /** Move what was attached on the new-chat screen to the chat created for it. */
-  readonly adopt: (held: HeldAttachments, chatId: number) => HeldAttachments;
+  /**
+   * Move what was attached on the new-chat screen to the chat created for it,
+   * under `scope` when that chat lives on another transport.
+   */
+  readonly adopt: (held: HeldAttachments, chatId: number, scope?: string) => HeldAttachments;
   /** Sent files are done with; refused ones go back to the composer. */
   readonly settle: (held: HeldAttachments, outcome: SendOutcome) => void;
   /** Drop a deleted chat's unsent files. */
@@ -97,8 +100,9 @@ export function useChatAttachments({
   chat,
 }: UseChatAttachmentsOptions): ChatAttachments {
   const { data: session } = useSession();
+  const userId = session?.userId;
   // Keyed by user so one account never sees another's files in the same tab.
-  const owner = session?.userId ? `${session.userId}|${scope}` : null;
+  const owner = userId ? `${userId}|${scope}` : null;
   const bucket = owner ? bucketFor(owner, chatId) : null;
   const store = useMemo(() => (typeof window === 'undefined' ? null : getStore()), []);
 
@@ -169,15 +173,17 @@ export function useChatAttachments({
   }, [store, bucket, owner, chatId]);
 
   const adopt = useCallback(
-    (held: HeldAttachments, nextChatId: number): HeldAttachments => {
-      if (store && held.owner) {
-        store.move(bucketFor(held.owner, held.chatId), bucketFor(held.owner, nextChatId));
+    (held: HeldAttachments, nextChatId: number, nextScope?: string): HeldAttachments => {
+      const nextOwner =
+        held.owner && userId && nextScope != null ? `${userId}|${nextScope}` : held.owner;
+      if (store && held.owner && nextOwner) {
+        store.move(bucketFor(held.owner, held.chatId), bucketFor(nextOwner, nextChatId));
       }
-      const adopted = { ...held, chatId: nextChatId };
+      const adopted = { ...held, owner: nextOwner, chatId: nextChatId };
       if (unsettledRef.current.delete(held)) unsettledRef.current.add(adopted);
       return adopted;
     },
-    [store]
+    [store, userId]
   );
 
   const settle = useCallback(
diff --git a/hooks/useChatSession.ts b/hooks/useChatSession.ts
index 18cc5b9be..7d793d4ed 100644
--- a/hooks/useChatSession.ts
+++ b/hooks/useChatSession.ts
@@ -49,6 +49,13 @@ export interface UseChatSessionOptions {
   readonly onListStale?: () => void;
   /** Extra fields for the chat the first message creates. */
   readonly getCreateInit?: () => ChatCreateInit | undefined;
+  /**
+   * Where the first message's chat is created, when that is not `transport`:
+   * a surface whose chats live on something the first message brings into
+   * being (the workspace creates the document first). Its failures are the
+   * creation's. Without it the chat is created on `transport`.
+   */
+  readonly transportForNewChat?: () => Promise<ChatTransport>;
   readonly notices: ChatNoticePolicy;
 }
 
@@ -96,6 +103,7 @@ export function useChatSession({
   onChatCreated,
   onListStale,
   getCreateInit,
+  transportForNewChat,
   notices,
 }: UseChatSessionOptions): ChatSession {
   const sessionKey = sessionKeyFor(transport, chatId);
@@ -226,8 +234,10 @@ export function useChatSession({
         setCreatingChat(true);
         let created: AgentChat | null = null;
         let failure: string | null = null;
+        let creationTransport = transport;
         try {
-          created = await transport.createChat(getCreateInit?.());
+          if (transportForNewChat) creationTransport = await transportForNewChat();
+          created = await creationTransport.createChat(getCreateInit?.());
         } catch (error) {
           failure = chatErrorDetail(error) ?? null;
         }
@@ -253,14 +263,16 @@ export function useChatSession({
         }
         draftsRef.current.delete(session);
         // A rejected first attempt must retry with the same model and settings.
-        const createdKey = sessionKeyFor(transport, created.conversation_id);
+        // Keyed by where the chat was created, which is where the surface opens
+        // it next, so the queued message and the model choice meet it there.
+        const createdKey = sessionKeyFor(creationTransport, created.conversation_id);
         modelSelection.adoptConversation(createdKey, generation);
         setCreatedChat(created);
         setQueuedMessage({
           sessionKey: createdKey,
           text,
           generation,
-          held: attachments.adopt(held, created.conversation_id),
+          held: attachments.adopt(held, created.conversation_id, creationTransport.key),
         });
         onChatCreated(created);
         return;
@@ -293,6 +305,7 @@ export function useChatSession({
       setDraft,
       isCurrentSession,
       getCreateInit,
+      transportForNewChat,
       onListStale,
       onChatCreated,
       notices.noun,
diff --git a/services/note.service.ts b/services/note.service.ts
index 9a6a77982..05d97c15c 100644
--- a/services/note.service.ts
+++ b/services/note.service.ts
@@ -57,6 +57,8 @@ export interface UpdateNoteParams {
 export interface GetOrganizationNotesParams {
   status?: 'DRAFT' | 'PUBLISHED';
   documentType?: 'PREREGISTRATION' | 'GRANT' | 'DISCUSSION' | 'REGISTERED_REPORT';
+  /** Latest edit first; servers that don't know it keep their newest-created order. */
+  ordering?: '-updated_date';
   nextUrl?: string;
 }
 
@@ -162,6 +164,7 @@ export class NoteService {
       const queryParams = new URLSearchParams();
       if (params?.status) queryParams.append('status', params.status);
       if (params?.documentType) queryParams.append('type', params.documentType);
+      if (params?.ordering) queryParams.append('ordering', params.ordering);
       const qs = queryParams.toString();
 
       const url =