@@ -75,10 +75,8 @@ interface AvailableItemsByType {
 }
 
 /**
- * Folder hierarchies that exist purely to structure the browse menus. Unlike
- * workflow (`folder`) and workspace-file (`filefolder`) folders these are not
- * attachable resources, so they stay out of `groups` — which also feeds the
- * flat search results, where a non-attachable row would be a dead end.
+ * Table and knowledge-base folder hierarchies. Chat also offers these as folder
+ * mentions, while the resource tab picker uses them only for navigation.
  */
 interface StructureFolders {
   table: AvailableItem[]
@@ -97,6 +95,8 @@ interface AvailableResources {
 }
 
 interface UseAvailableResourcesOptions {
+  /** Chat can attach every folder family, so these lists also gate mention hydration. */
+  includeFolderMentions?: boolean
   /**
    * Skips the underlying list queries and the group construction they feed
    * while `false`, returning a stable empty result. Menus pass their own open
@@ -171,16 +171,17 @@ export function useAvailableResources(
     { enabled }
   )
   const { data: folders, isPending: foldersPending } = useFolders(workspaceId, { enabled })
-  // Folder lists exist only to shape their family's submenu, so they skip the
-  // fetch entirely when that family is excluded.
-  const { data: tableFolders } = useFolders(workspaceId, {
+  const { data: tableFolders, isPending: tableFoldersPending } = useFolders(workspaceId, {
     enabled: enabled && !excludeTypes?.includes('table'),
     resourceType: 'table',
   })
-  const { data: knowledgeBaseFolders } = useFolders(workspaceId, {
-    enabled: enabled && !excludeTypes?.includes('knowledgebase'),
-    resourceType: 'knowledge_base',
-  })
+  const { data: knowledgeBaseFolders, isPending: knowledgeBaseFoldersPending } = useFolders(
+    workspaceId,
+    {
+      enabled: enabled && !excludeTypes?.includes('knowledgebase'),
+      resourceType: 'knowledge_base',
+    }
+  )
   const { data: fileFolders, isPending: fileFoldersPending } = useWorkspaceFileFolders(
     workspaceId,
     'active',
@@ -199,10 +200,8 @@ export function useAvailableResources(
    * settles to "not hydrating" — an errored query must not block the caller
    * forever.
    *
-   * Only the lists feeding `groups` count. The table and knowledge-base folder
-   * lists shape submenus but never add candidates, so gating on them would
-   * swallow an `@`-mention Enter behind two round-trips that cannot change the
-   * answer.
+   * Chat includes table and knowledge-base folders as candidates. Its Enter
+   * handling must wait for those lists too, or an unresolved mention can submit.
    */
   const isHydrating =
     enabled &&
@@ -211,6 +210,9 @@ export function useAvailableResources(
       filesPending ||
       knowledgeBasesPending ||
       foldersPending ||
+      (options?.includeFolderMentions &&
+        ((!excludeTypes?.includes('table') && tableFoldersPending) ||
+          (!excludeTypes?.includes('knowledgebase') && knowledgeBaseFoldersPending))) ||
       fileFoldersPending ||
       tasksPending ||
       logsPending)
@@ -371,9 +373,7 @@ interface ResourceFolderTreeItemsProps {
   /** Resource type of the leaf items. */
   type: MothershipResourceType
   /**
-   * Set when the folder is itself an attachable resource (workspace files): the
-   * folder is then offered as the first entry of its own submenu. Omitted for
-   * folders that only provide structure (workflows, tables, knowledge bases).
+   * Offers the folder itself as the first entry of its submenu when selectable.
    */
   folderType?: MothershipResourceType
   onSelect: (resource: MothershipResource) => void
@@ -429,10 +429,6 @@ export function ResourceFolderTreeItems({
 interface FolderedSectionSpec {
   /** Leaf resource type — also supplies the submenu's label and icon. */
   type: MothershipResourceType
-  /**
-   * Where this family's folders come from: another entry in `groups` when the
-   * folders are attachable resources, or `structureFolders` when they are not.
-   */
   folders:
     | { kind: 'group'; type: MothershipResourceType }
     | { kind: 'structure'; key: keyof StructureFolders }
@@ -483,22 +479,25 @@ export interface ResourceTreeSection {
 export function useResourceTreeSections({
   groups,
   structureFolders,
-}: Pick<AvailableResources, 'groups' | 'structureFolders'>): ResourceTreeSection[] {
+  selectFolders = false,
+}: Pick<AvailableResources, 'groups' | 'structureFolders'> & {
+  selectFolders?: boolean
+}): ResourceTreeSection[] {
   return useMemo(() => {
     const itemsOf = (type: MothershipResourceType) =>
       groups.find((group) => group.type === type)?.items ?? []
     return FOLDERED_SECTION_SPECS.map((spec) => ({
       type: spec.type,
-      folderType: spec.folderType,
+      folderType: spec.folderType ?? (selectFolders ? 'folder' : undefined),
       nodes: buildResourceFolderTree(
         itemsOf(spec.type),
         spec.folders.kind === 'group'
           ? itemsOf(spec.folders.type)
           : structureFolders[spec.folders.key],
-        { orderBySortOrder: spec.orderBySortOrder, pruneEmpty: !spec.folderType }
+        { orderBySortOrder: spec.orderBySortOrder, pruneEmpty: !selectFolders && !spec.folderType }
       ),
     })).filter((section) => section.nodes.length > 0)
-  }, [groups, structureFolders])
+  }, [groups, structureFolders, selectFolders])
 }
 
 interface ResourceMenuSectionsProps {
 
@@ -10,7 +10,18 @@ const fixtures = vi.hoisted(() => ({
   browserAvailable: vi.fn(() => true),
   terminalAvailable: vi.fn(() => true),
   resources: { data: [{ id: 'resource-1', name: 'Example' }], isPending: false },
-  folders: { data: [], isPending: false },
+  folders: {
+    data: [] as { id: string; name: string; parentId: string | null }[],
+    isPending: false,
+  },
+  tableFolders: {
+    data: [] as { id: string; name: string; parentId: string | null }[],
+    isPending: false,
+  },
+  knowledgeFolders: {
+    data: [] as { id: string; name: string; parentId: string | null }[],
+    isPending: false,
+  },
   tabs: [],
   logs: {
     data: {
@@ -32,7 +43,14 @@ vi.mock('@/hooks/queries/workspace-files', () => ({ useWorkspaceFiles: () => fix
 vi.mock('@/hooks/queries/kb/knowledge', () => ({
   useKnowledgeBasesQuery: () => fixtures.resources,
 }))
-vi.mock('@/hooks/queries/folders', () => ({ useFolders: () => fixtures.folders }))
+vi.mock('@/hooks/queries/folders', () => ({
+  useFolders: (_workspaceId: string, options?: { resourceType?: string }) =>
+    options?.resourceType === 'table'
+      ? fixtures.tableFolders
+      : options?.resourceType === 'knowledge_base'
+        ? fixtures.knowledgeFolders
+        : fixtures.folders,
+}))
 vi.mock('@/hooks/queries/workspace-file-folders', () => ({
   useWorkspaceFileFolders: () => fixtures.folders,
 }))
@@ -72,14 +90,15 @@ const PREFERENCES: DesktopPreferences = {
   terminalEnabled: true,
 }
 
-function openMenu(mention = false) {
+function openMenu(mention = false, mentionQuery?: string) {
   const ref = createRef<PlusMenuHandle>()
   const onResourceSelect = vi.fn()
   act(() =>
     root.render(
       <PlusMenuDropdown
         ref={ref}
         workspaceId='workspace-1'
+        mentionQuery={mentionQuery}
         onResourceSelect={onResourceSelect}
         onClose={vi.fn()}
         textareaRef={createRef<HTMLTextAreaElement>()}
@@ -120,6 +139,11 @@ describe('PlusMenuDropdown desktop resources', () => {
       }
     )
     vi.clearAllMocks()
+    fixtures.resources.data = [{ id: 'resource-1', name: 'Example' }]
+    for (const folders of [fixtures.folders, fixtures.tableFolders, fixtures.knowledgeFolders]) {
+      folders.data = []
+      folders.isPending = false
+    }
     fixtures.browserAvailable.mockReturnValue(true)
     fixtures.terminalAvailable.mockReturnValue(true)
     setDesktopPreferencesSnapshot(PREFERENCES)
@@ -231,4 +255,42 @@ describe('PlusMenuDropdown desktop resources', () => {
     expect(names).not.toContain('Browser')
     expect(names).not.toContain('Terminal')
   })
+
+  it.each(['tableFolders', 'knowledgeFolders'] as const)(
+    'selects an empty %s folder by @ mention and preserves its ID',
+    (family) => {
+      fixtures[family].data = [{ id: 'folder-1', name: 'Planning', parentId: null }]
+      const { ref, onResourceSelect } = openMenu(true, 'Planning')
+      act(() => {
+        expect(ref.current?.selectActive()).toBe('selected')
+      })
+      expect(mapResourceToContext(onResourceSelect.mock.calls[0][0])).toEqual({
+        kind: 'folder',
+        folderId: 'folder-1',
+        label: 'Planning',
+      })
+    }
+  )
+
+  it.each(['tableFolders', 'knowledgeFolders'] as const)(
+    'waits for %s hydration before submitting an unresolved mention',
+    (family) => {
+      fixtures[family].isPending = true
+      const { ref, onResourceSelect } = openMenu(true, 'Planning')
+      expect(ref.current?.selectActive()).toBe('hydrating')
+      expect(onResourceSelect).not.toHaveBeenCalled()
+    }
+  )
+
+  it('keeps empty table and knowledge folder families in the attachment browse menu', () => {
+    fixtures.resources.data = []
+    fixtures.tableFolders.data = [{ id: 'table-folder', name: 'Table Planning', parentId: null }]
+    fixtures.knowledgeFolders.data = [
+      { id: 'kb-folder', name: 'Knowledge Planning', parentId: null },
+    ]
+    openMenu()
+    expect(menuItems().map((item) => item.textContent)).toEqual(
+      expect.arrayContaining(['Tables', 'Knowledge Bases'])
+    )
+  })
 })
@@ -25,6 +25,7 @@ import {
   buildMentionPreview,
   resourceMentionMatches,
   withDesktopTabMentions,
+  withFolderMentions,
 } from '@/app/workspace/[workspaceId]/home/components/user-input/components/plus-menu-dropdown/resource-mention-items'
 import type {
   MothershipResource,
@@ -103,6 +104,7 @@ export const PlusMenuDropdown = React.memo(
       isHydrating,
     } = useAvailableResources(workspaceId, {
       enabled: open || !!warm,
+      includeFolderMentions: true,
     })
 
     const doOpen = useCallback(
@@ -121,15 +123,17 @@ export const PlusMenuDropdown = React.memo(
     }, [])
 
     const visibleResources = useMemo(() => {
+      const resources = withFolderMentions(availableResources, structureFolders)
       if (isMention) {
-        return withDesktopTabMentions(availableResources, browserTabs, terminalTabs)
+        return withDesktopTabMentions(resources, browserTabs, terminalTabs)
       }
-      return availableResources.filter(({ type }) => !MENTION_ONLY_RESOURCE_TYPES.has(type))
-    }, [availableResources, browserTabs, isMention, terminalTabs])
+      return resources.filter(({ type }) => !MENTION_ONLY_RESOURCE_TYPES.has(type))
+    }, [availableResources, structureFolders, browserTabs, isMention, terminalTabs])
 
     const treeSections = useResourceTreeSections({
-      groups: visibleResources,
+      groups: availableResources,
       structureFolders,
+      selectFolders: true,
     })
 
     const filteredItems = useMemo(() => {
 
@@ -9,6 +9,7 @@ import {
   buildMentionPreview,
   resourceMentionMatches,
   withDesktopTabMentions,
+  withFolderMentions,
 } from '@/app/workspace/[workspaceId]/home/components/user-input/components/plus-menu-dropdown/resource-mention-items'
 
 const groups = [
@@ -172,3 +173,31 @@ describe('byResourceMenuOrder', () => {
     expect(ordered.map((group) => group.type)).toEqual(['task', 'workflow', 'log', 'browser'])
   })
 })
+
+describe('folder mentions', () => {
+  it('includes nested and empty table and knowledge folders without changing the browse groups', () => {
+    const source = [
+      { type: 'folder' as const, items: [{ id: 'workflow-folder', name: 'Planning' }] },
+    ]
+    const result = withFolderMentions(source, {
+      table: [{ id: 'table-folder', name: 'Planning', parentId: 'parent' }],
+      knowledgebase: [{ id: 'kb-folder', name: 'Planning', parentId: null }],
+    })
+    expect(source[0].items).toHaveLength(1)
+    expect(result[0].items.map((item) => item.id)).toEqual([
+      'workflow-folder',
+      'table-folder',
+      'kb-folder',
+    ])
+    expect(
+      result[0].items
+        .filter((item) => resourceMentionMatches(item, 'table folders'))
+        .map((item) => item.id)
+    ).toEqual(['table-folder'])
+    expect(
+      result[0].items
+        .filter((item) => resourceMentionMatches(item, 'knowledge base folders'))
+        .map((item) => item.id)
+    ).toEqual(['kb-folder'])
+  })
+})
@@ -13,6 +13,28 @@ export interface ResourceMentionGroup {
   items: AvailableItem[]
 }
 
+/** Adds table and knowledge-base folders as stable folder-ID chat mentions. */
+export function withFolderMentions(
+  groups: readonly ResourceMentionGroup[],
+  folders: { table: AvailableItem[]; knowledgebase: AvailableItem[] }
+): ResourceMentionGroup[] {
+  return groups.map((group) =>
+    group.type === 'folder'
+      ? {
+          ...group,
+          items: [
+            ...group.items,
+            ...folders.table.map((item) => ({ ...item, mentionFamily: 'Table folders' })),
+            ...folders.knowledgebase.map((item) => ({
+              ...item,
+              mentionFamily: 'Knowledge base folders',
+            })),
+          ],
+        }
+      : group
+  )
+}
+
 export type ResourceMentionLevel = 'resource' | 'tab'
 
 /** A family query such as "browser" keeps that resource's live tabs visible. */
 
@@ -430,3 +430,54 @@ describe('usePromptEditor context insertion', () => {
     unmount()
   })
 })
+
+describe('folder resource mention identity', () => {
+  it('retains distinct folder IDs and labels when inserting a batch', () => {
+    const { result, unmount } = renderPromptEditor({ workspaceId: 'ws-1' })
+    try {
+      act(() =>
+        result().insertResources([
+          { type: 'folder', id: 'workflow-folder', title: 'Planning' },
+          { type: 'folder', id: 'table-folder', title: 'Planning' },
+          { type: 'folder', id: 'knowledge-folder', title: 'Planning' },
+          { type: 'filefolder', id: 'file-folder', title: 'Planning' },
+          { type: 'folder', id: 'table-folder', title: 'Planning' },
+        ])
+      )
+      expect(result().contexts).toEqual([
+        { kind: 'folder', folderId: 'workflow-folder', label: 'Planning' },
+        { kind: 'folder', folderId: 'table-folder', label: 'Planning (2)' },
+        { kind: 'folder', folderId: 'knowledge-folder', label: 'Planning (3)' },
+        { kind: 'filefolder', fileFolderId: 'file-folder', label: 'Planning (4)' },
+      ])
+      expect(result().value).toBe(
+        '@Planning @Planning (2) @Planning (3) @Planning (4) @Planning (2) '
+      )
+    } finally {
+      unmount()
+    }
+  })
+
+  it('keeps same-named folders as separate chips and reuses the label for a repeated ID', () => {
+    const { result, unmount } = renderPromptEditor({ workspaceId: 'ws-1' })
+    try {
+      act(() =>
+        result().insertResource({ type: 'folder', id: 'workflow-folder', title: 'Planning' })
+      )
+      act(() => result().insertResource({ type: 'folder', id: 'table-folder', title: 'Planning' }))
+      act(() =>
+        result().insertResource({ type: 'folder', id: 'knowledge-folder', title: 'Planning' })
+      )
+      act(() => result().insertResource({ type: 'folder', id: 'table-folder', title: 'Planning' }))
+      expect(result().contexts).toEqual([
+        { kind: 'folder', folderId: 'workflow-folder', label: 'Planning' },
+        { kind: 'folder', folderId: 'table-folder', label: 'Planning (2)' },
+        { kind: 'folder', folderId: 'knowledge-folder', label: 'Planning (3)' },
+      ])
+      expect(result().value).toContain('@Planning (2)')
+      expect(result().value).toContain('@Planning (3)')
+    } finally {
+      unmount()
+    }
+  })
+})