From 31a496517565abd0a422f636cc8c4b33c2e62593 Mon Sep 17 00:00:00 2001
From: Kobe Attias <kobeattias@gmail.com>
Date: Tue, 6 Oct 2026 16:36:38 -0400
Subject: [PATCH] Documents live in the sidebar, and the workspace is chat
 first with History

Drafts and Published list the user's RFPs and proposals under the nav on
every page, loaded once in a provider that My Funding's drafts read too.
The workspace keeps the app's sidebar, with the chat on the left and the
document on the right. A document opens on its most recent chat; History
switches between its chats or starts a new one, and the chat's menu
renames or deletes it. A new draft's first message creates the note,
then a chat on it. A dot shows the assistant at work on the document,
whose details are fetched again once a turn settles. Every signed-in
user drafts here, and the old ?ai= links are gone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 app/layouts/LeftSidebar.tsx                   |  64 ++-
 app/layouts/Navigation.tsx                    |   6 +-
 app/layouts/PageLayout.tsx                    |   8 +-
 app/layouts/PublishMenu.tsx                   | 201 ++--------
 .../components/LeftSidebarContainer.tsx       |   8 +-
 app/layouts/components/SidebarDocuments.tsx   | 168 ++++++++
 app/layouts/components/SidebarRow.tsx         |  32 ++
 .../components/MyFundingContent.tsx           |   6 +-
 app/notebook/[orgSlug]/page.tsx               |  49 +--
 app/workspace/WorkspaceClient.tsx             |   2 +-
 components/AIMode/AIModeContext.tsx           |  21 +-
 components/AIMode/LegacyAIModeRedirect.tsx    |  22 --
 components/AIMode/WorkspacePage.tsx           | 205 ++++------
 components/AIMode/chat/ChatMenu.tsx           |  85 ++++
 components/AIMode/chat/ChatPane.tsx           | 370 +++++++++++-------
 ...ationTitleField.tsx => ChatTitleField.tsx} |  14 +-
 components/AIMode/chat/DocumentCard.tsx       |  72 ----
 .../AIMode/chat/DocumentChatEmptyState.tsx    |  16 -
 components/AIMode/chat/conversationTitle.ts   |  33 --
 components/AIMode/copy.ts                     |  16 +-
 components/AIMode/document/DocumentPane.tsx   |  15 +
 .../AIMode/document/useAIModeDocument.ts      |  74 +++-
 components/AIMode/shell/WorkspacePanes.tsx    | 142 ++-----
 components/AIMode/shell/WorkspaceTopBar.tsx   |  15 +-
 .../AIMode/sidebar/ConversationMenu.tsx       | 131 -------
 .../AIMode/sidebar/ConversationsSection.tsx   | 137 -------
 components/AIMode/sidebar/DraftsSection.tsx   | 131 -------
 .../AIMode/sidebar/SidebarGroupHeading.tsx    |  19 -
 components/AIMode/sidebar/SidebarRow.tsx      |  69 ----
 .../AIMode/sidebar/WorkspaceSidebar.tsx       |  67 ----
 components/AIMode/start/StartContextChips.tsx |   2 +-
 components/AIMode/start/StartJourney.tsx      | 154 --------
 components/AIMode/start/StartScreen.tsx       |  44 +--
 components/AIMode/start/startComposer.ts      |   2 +-
 components/AIMode/start/useFundingIntent.ts   |   6 +-
 components/AIMode/useAIModeChat.ts            | 337 ++++++++--------
 components/AIMode/useWorkspaceTarget.ts       |  56 +++
 components/AIMode/workspaceUrl.ts             |  96 ++---
 components/AgentChat/AssistantActivityDot.tsx |  30 ++
 components/AgentChat/ChatEmptyState.tsx       |  51 +++
 components/AgentChat/ChatPicker.tsx           |  68 +++-
 components/Funding/createFundingDraft.ts      |  74 ++++
 .../Funding/dashboard/DraftCarousel.tsx       |  14 +-
 .../dashboard/hooks/useMyFundingDocuments.ts  |  42 +-
 components/Funding/fundingDraftOptions.tsx    |  81 ++++
 components/Funding/useFundingDrafting.ts      |  33 +-
 components/Notebook/AgentChatPanel.tsx        |  42 +-
 .../PublishingForm/PublishingFormProvider.tsx |  43 +-
 .../PublishingForm/usePublishAction.ts        |   5 +
 components/providers/ClientProviders.tsx      |  30 +-
 components/skeletons/AIModeSkeleton.tsx       |  16 -
 contexts/FundingDocumentsContext.tsx          | 229 +++++++++++
 hooks/useAgentChat.ts                         |  10 +-
 hooks/useChatAttachments.ts                   |  22 +-
 hooks/useChatSession.ts                       |  19 +-
 services/note.service.ts                      |   3 +
 56 files changed, 1791 insertions(+), 1916 deletions(-)
 create mode 100644 app/layouts/components/SidebarDocuments.tsx
 create mode 100644 app/layouts/components/SidebarRow.tsx
 delete mode 100644 components/AIMode/LegacyAIModeRedirect.tsx
 create mode 100644 components/AIMode/chat/ChatMenu.tsx
 rename components/AIMode/chat/{ConversationTitleField.tsx => ChatTitleField.tsx} (80%)
 delete mode 100644 components/AIMode/chat/DocumentCard.tsx
 delete mode 100644 components/AIMode/chat/DocumentChatEmptyState.tsx
 delete mode 100644 components/AIMode/chat/conversationTitle.ts
 delete mode 100644 components/AIMode/sidebar/ConversationMenu.tsx
 delete mode 100644 components/AIMode/sidebar/ConversationsSection.tsx
 delete mode 100644 components/AIMode/sidebar/DraftsSection.tsx
 delete mode 100644 components/AIMode/sidebar/SidebarGroupHeading.tsx
 delete mode 100644 components/AIMode/sidebar/SidebarRow.tsx
 delete mode 100644 components/AIMode/sidebar/WorkspaceSidebar.tsx
 delete mode 100644 components/AIMode/start/StartJourney.tsx
 create mode 100644 components/AIMode/useWorkspaceTarget.ts
 create mode 100644 components/AgentChat/AssistantActivityDot.tsx
 create mode 100644 components/AgentChat/ChatEmptyState.tsx
 create mode 100644 components/Funding/createFundingDraft.ts
 create mode 100644 components/Funding/fundingDraftOptions.tsx
 create mode 100644 contexts/FundingDocumentsContext.tsx

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 =