From 6c5d2598d6f866d6cd2e1974303a5a2e89ef75de Mon Sep 17 00:00:00 2001
From: Jeremy lewi <jeremy@lewi.us>
Date: Sat, 3 Oct 2026 13:43:32 -0700
Subject: [PATCH] Show full Google Drive paths in picker search results

Signed-off-by: Jeremy lewi <jeremy@lewi.us>
---
 .../GoogleDriveResourcePickerDialog.test.tsx  | 167 ++++++++-
 .../GoogleDriveResourcePickerDialog.tsx       |  50 ++-
 .../Workspace/googleDriveBrowser.test.ts      |  83 +++--
 .../Workspace/googleDriveBrowser.ts           |  14 +-
 .../Workspace/googleDrivePaths.test.ts        | 345 ++++++++++++++++++
 .../components/Workspace/googleDrivePaths.ts  | 160 ++++++++
 app/test/fixtures/drive-paths.html            |  11 +
 app/test/fixtures/drive-paths.tsx             |  34 ++
 docs-dev/CUJs/assets/drive-search-paths.png   | Bin 0 -> 34574 bytes
 docs-dev/CUJs/drive-search-paths.md           |  41 +++
 testing/drive-paths/main.go                   |  58 +++
 11 files changed, 912 insertions(+), 51 deletions(-)
 create mode 100644 app/src/components/Workspace/googleDrivePaths.test.ts
 create mode 100644 app/src/components/Workspace/googleDrivePaths.ts
 create mode 100644 app/test/fixtures/drive-paths.html
 create mode 100644 app/test/fixtures/drive-paths.tsx
 create mode 100644 docs-dev/CUJs/assets/drive-search-paths.png
 create mode 100644 docs-dev/CUJs/drive-search-paths.md
 create mode 100644 testing/drive-paths/main.go

diff --git a/app/src/components/Workspace/GoogleDriveResourcePickerDialog.test.tsx b/app/src/components/Workspace/GoogleDriveResourcePickerDialog.test.tsx
index c80fa5f2..abcbcc13 100644
--- a/app/src/components/Workspace/GoogleDriveResourcePickerDialog.test.tsx
+++ b/app/src/components/Workspace/GoogleDriveResourcePickerDialog.test.tsx
@@ -1,5 +1,5 @@
 // @vitest-environment jsdom
-import { fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { GoogleDriveResourcePickerDialog } from './GoogleDriveResourcePickerDialog'
@@ -9,6 +9,7 @@ const mocks = vi.hoisted(() => ({
   listChildren: vi.fn(),
   listRoots: vi.fn(),
   searchResources: vi.fn(),
+  resolvePaths: vi.fn(),
 }))
 
 vi.mock('./googleDriveBrowser', async () => {
@@ -23,8 +24,14 @@ vi.mock('./googleDriveBrowser', async () => {
   }
 })
 
+vi.mock('./googleDrivePaths', () => ({
+  resolveGoogleDriveResourcePaths: mocks.resolvePaths,
+}))
+
 describe('GoogleDriveResourcePickerDialog', () => {
   beforeEach(() => {
+    mocks.resolvePaths.mockReset()
+    mocks.resolvePaths.mockResolvedValue(undefined)
     mocks.listRoots.mockReset()
     mocks.listRoots.mockResolvedValue([
       { id: 'my-drive-root-id', name: 'My Drive' },
@@ -118,9 +125,7 @@ describe('GoogleDriveResourcePickerDialog', () => {
   it('keeps an actionable error open and retries root listing', async () => {
     mocks.listRoots
       .mockRejectedValueOnce(new Error('Drive API disabled'))
-      .mockResolvedValueOnce([
-        { id: 'my-drive-root-id', name: 'My Drive' },
-      ])
+      .mockResolvedValueOnce([{ id: 'my-drive-root-id', name: 'My Drive' }])
     render(
       <GoogleDriveResourcePickerDialog
         accessToken="token"
@@ -276,3 +281,157 @@ describe('GoogleDriveResourcePickerDialog', () => {
     trigger.remove()
   })
 })
+
+/** Starts a search only after root discovery has completed. */
+async function searchNotebooks() {
+  await screen.findByRole('button', { name: 'Open My Drive' })
+  fireEvent.change(screen.getByRole('searchbox'), {
+    target: { value: 'Notebooks' },
+  })
+  fireEvent.click(screen.getByRole('button', { name: 'Search' }))
+}
+
+it('shows duplicate names immediately and progressively adds accessible full paths', async () => {
+  mocks.listRoots.mockResolvedValue([{ id: 'my-root', name: 'My Drive' }])
+  mocks.searchResources.mockResolvedValue([
+    {
+      id: 'a',
+      name: 'Notebooks',
+      mimeType: 'application/vnd.google-apps.folder',
+    },
+    {
+      id: 'b',
+      name: 'Notebooks',
+      mimeType: 'application/vnd.google-apps.folder',
+    },
+  ])
+  let publish!: (id: string, path: { label: string; complete: boolean }) => void
+  let finish!: () => void
+  mocks.resolvePaths.mockImplementation((_token, _matches, _roots, onPath) => {
+    publish = onPath
+    return new Promise<void>((resolve) => {
+      finish = resolve
+    })
+  })
+  render(
+    <GoogleDriveResourcePickerDialog
+      accessToken="token"
+      mode="folder"
+      onCancel={vi.fn()}
+      onSelect={vi.fn()}
+    />
+  )
+  await searchNotebooks()
+  expect(
+    await screen.findAllByRole('button', { name: 'Open folder Notebooks' })
+  ).toHaveLength(2)
+  expect(screen.getAllByText('Loading path…')).toHaveLength(2)
+  await act(async () => {
+    publish('a', { label: 'My Drive / Work / Notebooks', complete: true })
+    publish('b', { label: 'Engineering / Team / Notebooks', complete: true })
+    finish()
+  })
+  const rows = screen.getAllByRole('button', { name: 'Open folder Notebooks' })
+  expect(
+    document.getElementById(rows[0].getAttribute('aria-describedby')!)
+      ?.textContent
+  ).toBe('My Drive / Work / Notebooks')
+  expect(screen.getByTitle('Engineering / Team / Notebooks')).toBeTruthy()
+})
+
+it.each(['navigation', 'new search', 'credentials', 'unmount'])(
+  'aborts paths and ignores late callbacks after %s',
+  async (action) => {
+    mocks.listRoots.mockResolvedValue([{ id: 'my-root', name: 'My Drive' }])
+    mocks.listChildren.mockResolvedValue([])
+    mocks.searchResources.mockResolvedValue([
+      {
+        id: 'a',
+        name: 'Notebooks',
+        mimeType: 'application/vnd.google-apps.folder',
+      },
+    ])
+    const pending: Array<{
+      publish: (id: string, path: { label: string; complete: boolean }) => void
+      signal: AbortSignal
+      finish: () => void
+    }> = []
+    mocks.resolvePaths.mockImplementation(
+      (_token, _matches, _roots, publish, signal) =>
+        new Promise<void>((finish) => pending.push({ publish, signal, finish }))
+    )
+    const props = {
+      accessToken: 'token',
+      mode: 'folder' as const,
+      onCancel: vi.fn(),
+      onSelect: vi.fn(),
+    }
+    const view = render(<GoogleDriveResourcePickerDialog {...props} />)
+    await searchNotebooks()
+    await screen.findByRole('button', { name: 'Open folder Notebooks' })
+    const first = pending[0]
+    if (action === 'navigation')
+      fireEvent.click(
+        screen.getByRole('button', { name: 'Open folder Notebooks' })
+      )
+    if (action === 'new search') {
+      fireEvent.change(screen.getByRole('searchbox'), {
+        target: { value: 'Other' },
+      })
+      fireEvent.click(screen.getByRole('button', { name: 'Search' }))
+      await waitFor(() => expect(pending).toHaveLength(2))
+    }
+    if (action === 'credentials')
+      view.rerender(
+        <GoogleDriveResourcePickerDialog {...props} accessToken="other-token" />
+      )
+    if (action === 'unmount') view.unmount()
+    expect(first.signal.aborted).toBe(true)
+    await act(async () => {
+      first.publish('a', { label: 'Stale path', complete: true })
+      first.finish()
+      pending[1]?.finish()
+    })
+    expect(screen.queryByText('Stale path')).toBeNull()
+  }
+)
+
+it('keeps file selection usable while a partial path is published', async () => {
+  mocks.listRoots.mockResolvedValue([{ id: 'my-root', name: 'My Drive' }])
+  mocks.searchResources.mockResolvedValue([
+    {
+      id: 'file-id',
+      name: 'notes.json',
+      mimeType: 'application/json',
+      resourceKey: 'key',
+    },
+  ])
+  mocks.resolvePaths.mockImplementation(
+    async (_token, _matches, _roots, publish) => {
+      publish('file-id', {
+        label: '… / notes.json (partial path)',
+        complete: false,
+      })
+    }
+  )
+  const onSelect = vi.fn()
+  render(
+    <GoogleDriveResourcePickerDialog
+      accessToken="token"
+      mode="file"
+      onCancel={vi.fn()}
+      onSelect={onSelect}
+    />
+  )
+  await searchNotebooks()
+  fireEvent.click(
+    await screen.findByRole('button', { name: 'Select file notes.json' })
+  )
+  expect(screen.getByText('… / notes.json (partial path)')).toBeTruthy()
+  fireEvent.click(
+    screen.getByRole('button', { name: 'Select file', exact: true })
+  )
+  expect(onSelect).toHaveBeenCalledWith(
+    expect.objectContaining({ id: 'file-id', resourceKey: 'key' })
+  )
+})
diff --git a/app/src/components/Workspace/GoogleDriveResourcePickerDialog.tsx b/app/src/components/Workspace/GoogleDriveResourcePickerDialog.tsx
index b7331e5b..58ed753c 100644
--- a/app/src/components/Workspace/GoogleDriveResourcePickerDialog.tsx
+++ b/app/src/components/Workspace/GoogleDriveResourcePickerDialog.tsx
@@ -14,6 +14,11 @@ import type {
   GoogleDriveResource,
 } from './googleDriveBrowser'
 
+import {
+  resolveGoogleDriveResourcePaths,
+  type GoogleDriveResourcePath,
+} from './googleDrivePaths'
+
 export type GoogleDrivePickerMode = 'file' | 'folder'
 
 export type PickedGoogleDriveResource = {
@@ -54,6 +59,10 @@ export function GoogleDriveResourcePickerDialog({
 }: GoogleDriveResourcePickerDialogProps) {
   const dialogRef = useRef<HTMLElement | null>(null)
   const requestIdRef = useRef(0)
+  const pathsAbortRef = useRef<AbortController | null>(null)
+  const [paths, setPaths] = useState<Record<string, GoogleDriveResourcePath>>(
+    {}
+  )
   const [roots, setRoots] = useState<GoogleDriveLocation[]>([])
   const [breadcrumbs, setBreadcrumbs] = useState<GoogleDriveLocation[]>([])
   const [resources, setResources] = useState<GoogleDriveResource[]>([])
@@ -69,6 +78,8 @@ export function GoogleDriveResourcePickerDialog({
 
   const loadRoots = useCallback(async () => {
     const requestId = ++requestIdRef.current
+    pathsAbortRef.current?.abort()
+    setPaths({})
     setLoading(true)
     setErrorMessage('')
     setBreadcrumbs([])
@@ -107,6 +118,8 @@ export function GoogleDriveResourcePickerDialog({
       nextBreadcrumbs: GoogleDriveLocation[]
     ) => {
       const requestId = ++requestIdRef.current
+      pathsAbortRef.current?.abort()
+      setPaths({})
       setLoading(true)
       setErrorMessage('')
       setBreadcrumbs(nextBreadcrumbs)
@@ -155,6 +168,8 @@ export function GoogleDriveResourcePickerDialog({
         return
       }
       const requestId = ++requestIdRef.current
+      pathsAbortRef.current?.abort()
+      setPaths({})
       setLoading(true)
       setErrorMessage('')
       setActiveSearch(query)
@@ -169,6 +184,20 @@ export function GoogleDriveResourcePickerDialog({
         )
         if (requestId === requestIdRef.current) {
           setResources(matches)
+          setLoading(false)
+          const controller = new AbortController()
+          pathsAbortRef.current = controller
+          await resolveGoogleDriveResourcePaths(
+            accessToken,
+            matches,
+            roots,
+            (id, path) => {
+              if (requestId === requestIdRef.current) {
+                setPaths((previous) => ({ ...previous, [id]: path }))
+              }
+            },
+            controller.signal
+          )
         }
       } catch (error) {
         if (requestId !== requestIdRef.current) {
@@ -192,13 +221,14 @@ export function GoogleDriveResourcePickerDialog({
         }
       }
     },
-    [accessToken, loadRoots, mode]
+    [accessToken, loadRoots, mode, roots]
   )
 
   useEffect(() => {
     void loadRoots()
     return () => {
       requestIdRef.current += 1
+      pathsAbortRef.current?.abort()
     }
   }, [loadRoots])
 
@@ -445,10 +475,12 @@ export function GoogleDriveResourcePickerDialog({
             </p>
           ) : (
             <div id="google-drive-resource-picker-items" className="space-y-2">
-              {visibleResources.map((resource) => {
+              {visibleResources.map((resource, index) => {
                 const isFolder =
                   resource.mimeType === GOOGLE_DRIVE_FOLDER_MIME_TYPE
                 const selected = selectedFile?.id === resource.id
+                const pathLabel = paths[resource.id]?.label ?? 'Loading path…'
+                const pathId = `google-drive-resource-picker-path-${index}`
                 return (
                   <button
                     key={resource.id}
@@ -459,6 +491,7 @@ export function GoogleDriveResourcePickerDialog({
                         : `Select file ${resource.name}`
                     }
                     aria-pressed={isFolder ? undefined : selected}
+                    aria-describedby={activeSearch ? pathId : undefined}
                     className={`flex w-full items-center gap-3 rounded-nb-sm border px-3 py-3 text-left focus:outline-none focus:ring-2 focus:ring-nb-accent-soft ${
                       selected
                         ? 'border-nb-accent bg-nb-accent-muted'
@@ -476,8 +509,17 @@ export function GoogleDriveResourcePickerDialog({
                     }}
                   >
                     {isFolder ? <FolderIcon /> : <FileIcon />}
-                    <span className="min-w-0 flex-1 truncate">
-                      {resource.name}
+                    <span className="min-w-0 flex-1">
+                      <span className="block truncate">{resource.name}</span>
+                      {activeSearch ? (
+                        <span
+                          id={pathId}
+                          title={pathLabel}
+                          className="mt-1 block break-words text-xs text-nb-text-muted"
+                        >
+                          {pathLabel}
+                        </span>
+                      ) : null}
                     </span>
                     <span className="text-xs text-nb-text-muted">
                       {isFolder ? 'Folder' : 'File'}
diff --git a/app/src/components/Workspace/googleDriveBrowser.test.ts b/app/src/components/Workspace/googleDriveBrowser.test.ts
index 33c87893..c534101a 100644
--- a/app/src/components/Workspace/googleDriveBrowser.test.ts
+++ b/app/src/components/Workspace/googleDriveBrowser.test.ts
@@ -153,6 +153,7 @@ describe('googleDriveBrowser', () => {
         name: 'Designs shortcut',
         mimeType: 'application/vnd.google-apps.folder',
         driveId: undefined,
+        isShortcut: true,
         resourceKey: 'target-key',
       },
     ])
@@ -188,20 +189,22 @@ describe('googleDriveBrowser', () => {
   })
 
   it('searches all visible Drives and filters folder mode server-side', async () => {
-    const fetchImpl = vi.fn<typeof fetch>().mockImplementation(async () =>
-      new Response(
-        JSON.stringify({
-          files: [
-            {
-              id: 'folder-1',
-              name: "Bob's Plans",
-              mimeType: 'application/vnd.google-apps.folder',
-              driveId: 'drive-1',
-            },
-          ],
-        }),
-        { status: 200 }
-      )
+    const fetchImpl = vi.fn<typeof fetch>().mockImplementation(
+      async () =>
+        new Response(
+          JSON.stringify({
+            files: [
+              {
+                id: 'folder-1',
+                name: "Bob's Plans",
+                parents: ['parent'],
+                mimeType: 'application/vnd.google-apps.folder',
+                driveId: 'drive-1',
+              },
+            ],
+          }),
+          { status: 200 }
+        )
     )
 
     await expect(
@@ -215,12 +218,14 @@ describe('googleDriveBrowser', () => {
       {
         id: 'folder-1',
         name: "Bob's Plans",
+        parents: ['parent'],
         mimeType: 'application/vnd.google-apps.folder',
         driveId: 'drive-1',
       },
     ])
 
     const url = new URL(fetchImpl.mock.calls[0]?.[0] as string)
+    expect(url.searchParams.get('fields')).toContain('parents')
     expect(url.searchParams.get('corpora')).toBe('allDrives')
     expect(url.searchParams.get('q')).toBe(
       "name contains 'Bob\\'s \\\\ Plans' and trashed = false and " +
@@ -230,32 +235,33 @@ describe('googleDriveBrowser', () => {
   })
 
   it('keeps folder shortcuts in folder search results while filtering file targets', async () => {
-    const fetchImpl = vi.fn<typeof fetch>().mockImplementation(async () =>
-      new Response(
-        JSON.stringify({
-          files: [
-            {
-              id: 'folder-shortcut',
-              name: 'Designs',
-              mimeType: 'application/vnd.google-apps.shortcut',
-              shortcutDetails: {
-                targetId: 'folder-target',
-                targetMimeType: 'application/vnd.google-apps.folder',
+    const fetchImpl = vi.fn<typeof fetch>().mockImplementation(
+      async () =>
+        new Response(
+          JSON.stringify({
+            files: [
+              {
+                id: 'folder-shortcut',
+                name: 'Designs',
+                mimeType: 'application/vnd.google-apps.shortcut',
+                shortcutDetails: {
+                  targetId: 'folder-target',
+                  targetMimeType: 'application/vnd.google-apps.folder',
+                },
               },
-            },
-            {
-              id: 'file-shortcut',
-              name: 'Design notes',
-              mimeType: 'application/vnd.google-apps.shortcut',
-              shortcutDetails: {
-                targetId: 'file-target',
-                targetMimeType: 'text/plain',
+              {
+                id: 'file-shortcut',
+                name: 'Design notes',
+                mimeType: 'application/vnd.google-apps.shortcut',
+                shortcutDetails: {
+                  targetId: 'file-target',
+                  targetMimeType: 'text/plain',
+                },
               },
-            },
-          ],
-        }),
-        { status: 200 }
-      )
+            ],
+          }),
+          { status: 200 }
+        )
     )
 
     await expect(
@@ -266,6 +272,7 @@ describe('googleDriveBrowser', () => {
         name: 'Designs',
         mimeType: 'application/vnd.google-apps.folder',
         driveId: undefined,
+        isShortcut: true,
       },
     ])
 
diff --git a/app/src/components/Workspace/googleDriveBrowser.ts b/app/src/components/Workspace/googleDriveBrowser.ts
index 4684b1ce..817828b0 100644
--- a/app/src/components/Workspace/googleDriveBrowser.ts
+++ b/app/src/components/Workspace/googleDriveBrowser.ts
@@ -14,6 +14,9 @@ export type GoogleDriveLocation = {
 
 export type GoogleDriveResource = GoogleDriveLocation & {
   mimeType: string
+  parents?: string[]
+  /** A shortcut's name is an alias; its target ancestry must be fetched. */
+  isShortcut?: boolean
 }
 
 type DriveListResponse = {
@@ -79,6 +82,7 @@ function normalizeGoogleDriveResource(
       name: file.name,
       mimeType: file.shortcutDetails.targetMimeType,
       driveId: undefined,
+      isShortcut: true,
       ...(file.shortcutDetails.targetResourceKey
         ? { resourceKey: file.shortcutDetails.targetResourceKey }
         : {}),
@@ -90,12 +94,13 @@ function normalizeGoogleDriveResource(
     name: file.name,
     mimeType: file.mimeType,
     driveId: file.driveId ?? parentDriveId,
+    ...(Array.isArray(file.parents) ? { parents: file.parents } : {}),
     ...(file.resourceKey ? { resourceKey: file.resourceKey } : {}),
   }
 }
 
 /** Builds Drive's resource-key header for a protected item when available. */
-function driveResourceKeyHeader(
+export function driveResourceKeyHeader(
   location: Pick<GoogleDriveLocation, 'id' | 'resourceKey'>
 ): Record<string, string> {
   if (!location.resourceKey) {
@@ -110,7 +115,7 @@ function driveResourceKeyHeader(
  * Builds a Drive v3 URL against the configured runtime endpoint. The trailing
  * slash keeps relative API paths stable for production and test base URLs.
  */
-function driveApiUrl(path: string): URL {
+export function driveApiUrl(path: string): URL {
   const baseUrl = getGoogleDriveBaseUrl() || 'https://www.googleapis.com'
   return new URL(path, `${baseUrl}/`)
 }
@@ -353,7 +358,7 @@ export async function searchGoogleDriveResources(
       url.searchParams.set('pageSize', '100')
       url.searchParams.set(
         'fields',
-        'nextPageToken,incompleteSearch,files(id,name,mimeType,driveId,resourceKey,shortcutDetails(targetId,targetMimeType,targetResourceKey))'
+        'nextPageToken,incompleteSearch,files(id,name,mimeType,parents,driveId,resourceKey,shortcutDetails(targetId,targetMimeType,targetResourceKey))'
       )
       url.searchParams.set('spaces', 'drive')
       url.searchParams.set('corpora', 'allDrives')
@@ -395,8 +400,7 @@ export async function searchGoogleDriveResources(
   const distanceLimit = fuzzySearchDistanceLimit(comparableQuery.length)
   if (
     resources.some(
-      (resource) =>
-        normalizeSearchName(resource.name) === comparableQuery
+      (resource) => normalizeSearchName(resource.name) === comparableQuery
     )
   ) {
     return resources
diff --git a/app/src/components/Workspace/googleDrivePaths.test.ts b/app/src/components/Workspace/googleDrivePaths.test.ts
new file mode 100644
index 00000000..cb651a31
--- /dev/null
+++ b/app/src/components/Workspace/googleDrivePaths.test.ts
@@ -0,0 +1,345 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  clearGoogleDriveRuntime,
+  setGoogleDriveBaseUrl,
+} from '../../lib/googleDriveRuntime'
+import {
+  GOOGLE_DRIVE_FOLDER_MIME_TYPE,
+  type GoogleDriveResource,
+} from './googleDriveBrowser'
+import {
+  type GoogleDriveResourcePath,
+  resolveGoogleDriveResourcePaths,
+} from './googleDrivePaths'
+
+const roots = [
+  { id: 'my-root', name: 'My Drive' },
+  { id: 'shared', name: 'Engineering', driveId: 'shared' },
+]
+/** Search fixtures model ordinary folders unless explicitly overridden. */
+const folder = (
+  id: string,
+  parents?: string[],
+  extra: Partial<GoogleDriveResource> = {}
+): GoogleDriveResource => ({
+  id,
+  name: 'Notebooks',
+  mimeType: GOOGLE_DRIVE_FOLDER_MIME_TYPE,
+  parents,
+  ...extra,
+})
+/** Routes metadata fixtures by ID and records every network lookup. */
+function fixtureFetch(nodes: Record<string, unknown>) {
+  return vi.fn<typeof fetch>(async (input) => {
+    const id = decodeURIComponent(
+      new URL(String(input)).pathname.split('/').at(-1)!
+    )
+    return new Response(JSON.stringify(nodes[id] ?? {}), {
+      status: id in nodes ? 200 : 404,
+    })
+  })
+}
+/** Collects progressively published paths for assertions. */
+async function resolve(
+  resources: GoogleDriveResource[],
+  fetchImpl = fixtureFetch({})
+) {
+  const paths: Record<string, GoogleDriveResourcePath> = {}
+  await resolveGoogleDriveResourcePaths(
+    'token',
+    resources,
+    roots,
+    (id, path) => {
+      paths[id] = path
+    },
+    new AbortController().signal,
+    fetchImpl
+  )
+  return paths
+}
+
+describe('Google Drive search paths', () => {
+  afterEach(() => {
+    clearGoogleDriveRuntime()
+    vi.useRealTimers()
+  })
+
+  it('resolves a shortcut to a root absent from the initial root list', async () => {
+    const fetchImpl = vi.fn<typeof fetch>(async (input) => {
+      const isDrive = new URL(String(input)).pathname.includes('/drives/')
+      return new Response(
+        JSON.stringify(
+          isDrive
+            ? { id: 'outside', name: 'Other Drive' }
+            : { id: 'outside', name: 'Root', driveId: 'outside' }
+        )
+      )
+    })
+    expect(
+      (
+        await resolve(
+          [folder('outside', undefined, { isShortcut: true })],
+          fetchImpl
+        )
+      ).outside
+    ).toEqual({ label: 'Other Drive', complete: true })
+    expect(fetchImpl).toHaveBeenCalledTimes(2)
+  })
+
+  it('isolates forbidden, malformed JSON, and network errors to affected paths', async () => {
+    const fetchImpl = vi.fn<typeof fetch>(async (input) => {
+      const url = String(input)
+      if (url.includes('/forbidden?')) return new Response('', { status: 403 })
+      if (url.includes('/malformed?')) return new Response('not JSON')
+      throw new Error('network failure')
+    })
+    const paths = await resolve(
+      [
+        folder('a', ['forbidden']),
+        folder('b', ['malformed']),
+        folder('c', ['network']),
+        folder('d', ['my-root']),
+      ],
+      fetchImpl
+    )
+    expect([
+      paths.a.complete,
+      paths.b.complete,
+      paths.c.complete,
+      paths.d.complete,
+    ]).toEqual([false, false, false, true])
+  })
+
+  it('distinguishes duplicate names across roots and shares ancestor reads', async () => {
+    const fetchImpl = fixtureFetch({
+      team: {
+        id: 'team',
+        name: 'Runme',
+        parents: ['shared'],
+        driveId: 'shared',
+      },
+    })
+    const paths = await resolve(
+      [folder('a', ['team']), folder('b', ['team']), folder('c', ['my-root'])],
+      fetchImpl
+    )
+    expect(paths).toEqual({
+      a: { label: 'Engineering / Runme / Notebooks', complete: true },
+      b: { label: 'Engineering / Runme / Notebooks', complete: true },
+      c: { label: 'My Drive / Notebooks', complete: true },
+    })
+    expect(fetchImpl).toHaveBeenCalledTimes(1)
+  })
+
+  it('seeds ancestors from search results and recognizes known root results', async () => {
+    const fetchImpl = fixtureFetch({})
+    expect(
+      await resolve(
+        [
+          folder('a', ['team']),
+          folder('team', ['shared'], { name: 'Team' }),
+          folder('shared'),
+        ],
+        fetchImpl
+      )
+    ).toEqual({
+      a: { label: 'Engineering / Team / Notebooks', complete: true },
+      team: { label: 'Engineering / Team', complete: true },
+      shared: { label: 'Engineering', complete: true },
+    })
+    expect(fetchImpl).not.toHaveBeenCalled()
+  })
+
+  it('resolves unknown Shared Drive names once', async () => {
+    const fetchImpl = fixtureFetch({
+      outside: { id: 'outside', name: 'Other Drive' },
+    })
+    const paths = await resolve(
+      [
+        folder('a', ['outside'], { driveId: 'outside' }),
+        folder('b', ['outside'], { driveId: 'outside' }),
+      ],
+      fetchImpl
+    )
+    expect(paths.a.label).toBe('Other Drive / Notebooks')
+    expect(paths.b.complete).toBe(true)
+    expect(fetchImpl).toHaveBeenCalledTimes(1)
+    expect(new URL(String(fetchImpl.mock.calls[0][0])).pathname).toBe(
+      '/drive/v3/drives/outside'
+    )
+  })
+
+  it('resolves a shortcut target path with its resource key, never its alias ancestry', async () => {
+    setGoogleDriveBaseUrl('https://drive.example.test')
+    const fetchImpl = fixtureFetch({
+      target: {
+        id: 'target',
+        name: 'Canonical',
+        parents: ['shared'],
+        driveId: 'shared',
+      },
+    })
+    const paths = await resolve(
+      [
+        folder('target', undefined, {
+          isShortcut: true,
+          name: 'Alias',
+          resourceKey: 'key',
+        }),
+      ],
+      fetchImpl
+    )
+    expect(paths.target).toEqual({
+      label: 'Engineering / Canonical',
+      complete: true,
+    })
+    const [input, options] = fetchImpl.mock.calls[0]
+    const url = new URL(String(input))
+    expect(url.origin).toBe('https://drive.example.test')
+    expect(url.searchParams.get('fields')).toBe(
+      'id,name,parents,driveId,resourceKey'
+    )
+    expect(url.searchParams.get('supportsAllDrives')).toBe('true')
+    expect(options?.headers).toEqual({
+      Authorization: 'Bearer token',
+      'X-Goog-Drive-Resource-Keys': 'target/key',
+    })
+  })
+
+  it('keeps failed and parentless paths partial without guessing My Drive', async () => {
+    const fetchImpl = fixtureFetch({
+      team: { id: 'team', name: 'Team', parents: ['missing'] },
+      malformed: { id: 'wrong', name: 'Bad' },
+    })
+    const paths = await resolve(
+      [
+        folder('a', ['team']),
+        folder('b', ['missing']),
+        folder('c'),
+        folder('d', ['malformed']),
+        folder('target', undefined, { isShortcut: true }),
+      ],
+      fetchImpl
+    )
+    expect(paths.a).toEqual({
+      label: '… / Team / Notebooks (partial path)',
+      complete: false,
+    })
+    for (const id of ['b', 'c', 'd', 'target'])
+      expect(paths[id]).toEqual({
+        label: '… / Notebooks (partial path)',
+        complete: false,
+      })
+    expect(
+      fetchImpl.mock.calls.filter(([input]) =>
+        String(input).includes('/missing?')
+      )
+    ).toHaveLength(1)
+  })
+
+  it('terminates cycles and limits ancestry depth', async () => {
+    const cyclic = fixtureFetch({
+      team: { id: 'team', name: 'Team', parents: ['a'] },
+    })
+    expect((await resolve([folder('a', ['team'])], cyclic)).a.complete).toBe(
+      false
+    )
+    const deep = vi.fn<typeof fetch>(async (input) => {
+      const id = new URL(String(input)).pathname.split('/').at(-1)!
+      return new Response(
+        JSON.stringify({ id, name: id, parents: [String(Number(id) + 1)] })
+      )
+    })
+    expect((await resolve([folder('0', ['1'])], deep))['0'].complete).toBe(
+      false
+    )
+    expect(deep).toHaveBeenCalledTimes(99)
+  })
+
+  it('publishes fast paths while slow paths load and caps network concurrency at six', async () => {
+    const releases: Array<() => void> = []
+    let pending = 0
+    let peak = 0
+    const fetchImpl = vi.fn<typeof fetch>(async (input) => {
+      pending++
+      peak = Math.max(peak, pending)
+      await new Promise<void>((resolve) => releases.push(resolve))
+      pending--
+      const id = new URL(String(input)).pathname.split('/').at(-1)!
+      return new Response(JSON.stringify({ id, name: id, parents: ['shared'] }))
+    })
+    const onPath = vi.fn()
+    const done = resolveGoogleDriveResourcePaths(
+      'token',
+      [
+        folder('fast', ['my-root']),
+        ...Array.from({ length: 12 }, (_, i) =>
+          folder(`item-${i}`, [`parent-${i}`])
+        ),
+      ],
+      roots,
+      onPath,
+      new AbortController().signal,
+      fetchImpl
+    )
+    await vi.waitFor(() => expect(fetchImpl).toHaveBeenCalledTimes(6))
+    expect(onPath).toHaveBeenCalledWith('fast', {
+      label: 'My Drive / Notebooks',
+      complete: true,
+    })
+    releases.splice(0).forEach((release) => release())
+    await vi.waitFor(() => expect(fetchImpl).toHaveBeenCalledTimes(12))
+    releases.splice(0).forEach((release) => release())
+    await done
+    expect(peak).toBe(6)
+    expect(onPath).toHaveBeenCalledTimes(13)
+  })
+
+  it('aborts pending requests and does not publish or schedule further work', async () => {
+    const controller = new AbortController()
+    const fetchImpl = vi.fn<typeof fetch>(
+      (_input, init) =>
+        new Promise((_resolve, reject) =>
+          init?.signal?.addEventListener('abort', () =>
+            reject(new Error('aborted'))
+          )
+        )
+    )
+    const onPath = vi.fn()
+    const done = resolveGoogleDriveResourcePaths(
+      'token',
+      Array.from({ length: 10 }, (_, i) => folder(String(i), [`parent-${i}`])),
+      roots,
+      onPath,
+      controller.signal,
+      fetchImpl
+    )
+    await vi.waitFor(() => expect(fetchImpl).toHaveBeenCalledTimes(6))
+    controller.abort()
+    await done
+    expect(fetchImpl).toHaveBeenCalledTimes(6)
+    expect(onPath).not.toHaveBeenCalled()
+  })
+
+  it('times out unavailable metadata and allows a later search to retry', async () => {
+    vi.useFakeTimers()
+    const fetchImpl = vi.fn<typeof fetch>(
+      (_input, init) =>
+        new Promise((_resolve, reject) =>
+          init?.signal?.addEventListener('abort', () =>
+            reject(new Error('timeout'))
+          )
+        )
+    )
+    const done = resolve([folder('a', ['slow'])], fetchImpl)
+    await vi.advanceTimersByTimeAsync(10_000)
+    expect((await done).a.complete).toBe(false)
+    const retryFetch = fixtureFetch({
+      slow: { id: 'slow', name: 'Now available', parents: ['my-root'] },
+    })
+    expect(
+      (await resolve([folder('a', ['slow'])], retryFetch)).a.complete
+    ).toBe(true)
+  })
+})
diff --git a/app/src/components/Workspace/googleDrivePaths.ts b/app/src/components/Workspace/googleDrivePaths.ts
new file mode 100644
index 00000000..85b69f1b
--- /dev/null
+++ b/app/src/components/Workspace/googleDrivePaths.ts
@@ -0,0 +1,160 @@
+import {
+  type GoogleDriveLocation,
+  type GoogleDriveResource,
+  driveApiUrl,
+  driveResourceKeyHeader,
+} from './googleDriveBrowser'
+
+export type GoogleDriveResourcePath = {
+  label: string
+  complete: boolean
+}
+
+type Metadata = GoogleDriveLocation & { parents?: string[] }
+
+const PATH_WORKERS = 6
+const MAX_ANCESTORS = 100
+const METADATA_TIMEOUT_MS = 10_000
+
+/** Validates metadata before using API-provided names and parent links. */
+function isMetadata(value: Partial<Metadata>, id: string): value is Metadata {
+  return (
+    value.id === id &&
+    typeof value.name === 'string' &&
+    (value.parents === undefined ||
+      (Array.isArray(value.parents) &&
+        value.parents.every((parent) => typeof parent === 'string')))
+  )
+}
+
+/**
+ * Enriches search rows without blocking selection. Each search owns its cache
+ * of metadata promises, so siblings share in-flight reads and failed reads,
+ * while subsequent searches retry failures and observe moves/renames. Workers
+ * walk chains sequentially, bounding network concurrency without a nested queue.
+ */
+export async function resolveGoogleDriveResourcePaths(
+  accessToken: string,
+  resources: GoogleDriveResource[],
+  roots: GoogleDriveLocation[],
+  onPath: (id: string, path: GoogleDriveResourcePath) => void,
+  signal: AbortSignal,
+  fetchImpl: typeof fetch = fetch
+): Promise<void> {
+  const rootNames = new Map(roots.map((root) => [root.id, root.name]))
+  const metadata = new Map<string, Promise<Metadata | null>>()
+  const driveNames = new Map<string, Promise<Metadata | null>>()
+  const resourceKeys = new Map<string, string>()
+  for (const resource of resources) {
+    if (!resource.isShortcut) {
+      metadata.set(resource.id, Promise.resolve(resource))
+    }
+    if (resource.resourceKey) {
+      resourceKeys.set(resource.id, resource.resourceKey)
+    }
+  }
+
+  /** A failed or timed-out read leaves a usable, explicitly partial path. */
+  const readMetadata = async (
+    id: string,
+    kind: 'files' | 'drives'
+  ): Promise<Metadata | null> => {
+    if (signal.aborted) return null
+    const controller = new AbortController()
+    const abort = () => controller.abort()
+    signal.addEventListener('abort', abort, { once: true })
+    const timer = setTimeout(abort, METADATA_TIMEOUT_MS)
+    try {
+      const url = driveApiUrl(`drive/v3/${kind}/${encodeURIComponent(id)}`)
+      url.searchParams.set(
+        'fields',
+        kind === 'files' ? 'id,name,parents,driveId,resourceKey' : 'id,name'
+      )
+      if (kind === 'files') url.searchParams.set('supportsAllDrives', 'true')
+      const response = await fetchImpl(url, {
+        signal: controller.signal,
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          ...driveResourceKeyHeader({ id, resourceKey: resourceKeys.get(id) }),
+        },
+      })
+      if (!response.ok) return null
+      const value = (await response.json()) as Partial<Metadata>
+      return value && isMetadata(value, id) ? value : null
+    } catch {
+      return null
+    } finally {
+      clearTimeout(timer)
+      signal.removeEventListener('abort', abort)
+    }
+  }
+
+  /** Publish the promise before awaiting it to coalesce concurrent readers. */
+  const getMetadata = (id: string, kind: 'files' | 'drives') => {
+    const cache = kind === 'files' ? metadata : driveNames
+    let pending = cache.get(id)
+    if (!pending) {
+      pending = readMetadata(id, kind)
+      cache.set(id, pending)
+    }
+    return pending
+  }
+
+  /** Only a verified root makes a path complete; missing parents never do. */
+  const resolve = async (
+    resource: GoogleDriveResource
+  ): Promise<GoogleDriveResourcePath> => {
+    const names: string[] = []
+    const seen = new Set<string>()
+    let id: string | undefined = resource.id
+    let driveId = resource.driveId
+    for (let depth = 0; id && depth < MAX_ANCESTORS; depth += 1) {
+      if (signal.aborted || seen.has(id)) break
+      seen.add(id)
+      const rootName = rootNames.get(id)
+      if (rootName !== undefined) {
+        return { label: [rootName, ...names].join(' / '), complete: true }
+      }
+      if (id === driveId) {
+        const drive = await getMetadata(id, 'drives')
+        if (drive) {
+          return { label: [drive.name, ...names].join(' / '), complete: true }
+        }
+        break
+      }
+      const node = await getMetadata(id, 'files')
+      if (!node) break
+      // A shortcut can target a Shared Drive root without exposing driveId in
+      // the search result. Discover that root from the target metadata first.
+      if (node.driveId === id) {
+        const drive = await getMetadata(id, 'drives')
+        if (drive) {
+          return { label: [drive.name, ...names].join(' / '), complete: true }
+        }
+        names.unshift(node.name)
+        break
+      }
+      names.unshift(node.name)
+      driveId = node.driveId ?? driveId
+      id = node.parents?.[0]
+    }
+    // If even the target is unavailable, retain the visible search name.
+    return {
+      label: `… / ${(names.length ? names : [resource.name]).join(' / ')} (partial path)`,
+      complete: false,
+    }
+  }
+
+  let nextIndex = 0
+  /** Each worker reports completed rows independently of slower ancestors. */
+  const worker = async () => {
+    while (!signal.aborted && nextIndex < resources.length) {
+      const resource = resources[nextIndex++]
+      const path = await resolve(resource)
+      if (!signal.aborted) onPath(resource.id, path)
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(PATH_WORKERS, resources.length) }, worker)
+  )
+}
diff --git a/app/test/fixtures/drive-paths.html b/app/test/fixtures/drive-paths.html
new file mode 100644
index 00000000..5fda0ee6
--- /dev/null
+++ b/app/test/fixtures/drive-paths.html
@@ -0,0 +1,11 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>Drive search paths CUJ</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="./drive-paths.tsx"></script>
+  </body>
+</html>
diff --git a/app/test/fixtures/drive-paths.tsx b/app/test/fixtures/drive-paths.tsx
new file mode 100644
index 00000000..9bea5588
--- /dev/null
+++ b/app/test/fixtures/drive-paths.tsx
@@ -0,0 +1,34 @@
+import React, { useState } from 'react'
+import { createRoot } from 'react-dom/client'
+
+import { GoogleDriveResourcePickerDialog } from '../../src/components/Workspace/GoogleDriveResourcePickerDialog'
+import { setGoogleDriveBaseUrl } from '../../src/lib/googleDriveRuntime'
+import '../../src/index.css'
+
+setGoogleDriveBaseUrl('http://127.0.0.1:9098')
+
+/** Exercises the production picker and resolver against the Go Drive fixture. */
+export function DrivePathsFixture() {
+  const [open, setOpen] = useState(true)
+  const [selected, setSelected] = useState('')
+  return (
+    <main className="p-8">
+      <h1>Drive search paths — synthetic test data</h1>
+      <button onClick={() => setOpen(true)}>Open folder picker</button>
+      <p id="selected-resource">{selected}</p>
+      {open && (
+        <GoogleDriveResourcePickerDialog
+          accessToken="synthetic-test-token"
+          mode="folder"
+          onCancel={() => setOpen(false)}
+          onSelect={(resource) => {
+            setSelected(`Selected ID: ${resource.id}`)
+            setOpen(false)
+          }}
+        />
+      )}
+    </main>
+  )
+}
+
+createRoot(document.getElementById('root')!).render(<DrivePathsFixture />)
diff --git a/docs-dev/CUJs/assets/drive-search-paths.png b/docs-dev/CUJs/assets/drive-search-paths.png
new file mode 100644
index 0000000000000000000000000000000000000000..a7da6be1fd01945f6f23e78b6bfcb54979b8dc9b
GIT binary patch
literal 34574
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
S0Qt;5erfji)_~yqfqw$w6=#Y7

literal 0
HcmV?d00001

diff --git a/docs-dev/CUJs/drive-search-paths.md b/docs-dev/CUJs/drive-search-paths.md
new file mode 100644
index 00000000..22922627
--- /dev/null
+++ b/docs-dev/CUJs/drive-search-paths.md
@@ -0,0 +1,41 @@
+# Disambiguate Google Drive search results
+
+The production folder and file picker displays a full path below each search
+match. Paths load progressively; inaccessible ancestry is labeled partial.
+Selection uses Drive IDs, including when full paths themselves collide.
+
+## Reproduce with synthetic data
+
+1. Run `go run testing/drive-paths/main.go` from the repository root.
+2. Run `pnpm -C app dev --host 127.0.0.1 --port 5186`.
+3. Open `http://127.0.0.1:5186/test/fixtures/drive-paths.html`.
+4. Search for `Notebooks`.
+5. Verify three independently selectable rows with these descriptions:
+   - `My Drive / Projects / Notebooks`
+   - `Engineering / Runme / Notebooks`
+   - `… / Notebooks (partial path)`
+6. Open the Engineering result, then choose **Select this folder**.
+7. Verify the page reports `Selected ID: team-notebooks`.
+8. Reopen the picker and use keyboard focus to inspect path descriptions.
+
+The fixture imports the production React dialog and resolver and sends real
+HTTP requests to a read-only Go fixture. Its token and data are synthetic.
+The fixture is a Vite development entry point, not a production app route.
+Save screenshots and assertion transcripts under `app/test/browser/test-output/`.
+
+## Verified UI
+
+![Full and partial paths in the production picker with synthetic data](assets/drive-search-paths.png)
+
+## Regression coverage
+
+- `googleDriveBrowser.test.ts`: search requests and preserves parent IDs;
+  shortcut source parents are not attached to target IDs.
+- `googleDrivePaths.test.ts`: root naming, shared-ancestor request deduplication,
+  result-metadata reuse, target resource keys, inaccessible/malformed ancestors,
+  cycle/depth limits, bounded concurrency, timeout and cancellation.
+- `GoogleDriveResourcePickerDialog.test.tsx`: progressive path descriptions and
+  stale callback rejection after search, navigation, token changes and unmount.
+
+The design and implementation record is in
+[20261003_google_drive_full_paths.runme](https://web.runme.dev/?doc=https%3A%2F%2Fdrive.google.com%2Ffile%2Fd%2F100i8UJfmZyvqw-1UxFiIs5pxM2Nt79oC%2Fview).
diff --git a/testing/drive-paths/main.go b/testing/drive-paths/main.go
new file mode 100644
index 00000000..56e782ac
--- /dev/null
+++ b/testing/drive-paths/main.go
@@ -0,0 +1,58 @@
+// A read-only Drive fixture for the full-path picker CUJ. All data is synthetic.
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"log"
+	"net/http"
+	"strings"
+)
+
+func main() {
+	addr := flag.String("addr", "127.0.0.1:9098", "listen address")
+	flag.Parse()
+	folders := []map[string]any{
+		{"id": "personal-notebooks", "name": "Notebooks", "mimeType": "application/vnd.google-apps.folder", "parents": []string{"personal-projects"}},
+		{"id": "team-notebooks", "name": "Notebooks", "mimeType": "application/vnd.google-apps.folder", "parents": []string{"team-projects"}, "driveId": "engineering"},
+		{"id": "archive-notebooks", "name": "Notebooks", "mimeType": "application/vnd.google-apps.folder", "parents": []string{"restricted"}},
+	}
+	metadata := map[string]any{
+		"root":              map[string]any{"id": "my-root"},
+		"personal-projects": map[string]any{"id": "personal-projects", "name": "Projects", "parents": []string{"my-root"}},
+		"team-projects":     map[string]any{"id": "team-projects", "name": "Runme", "parents": []string{"engineering"}, "driveId": "engineering"},
+	}
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Headers", "Authorization, X-Goog-Drive-Resource-Keys")
+		w.Header().Set("Content-Type", "application/json")
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+		if r.Method != http.MethodGet {
+			w.WriteHeader(http.StatusMethodNotAllowed)
+			return
+		}
+		var response any
+		switch {
+		case r.URL.Path == "/drive/v3/drives":
+			response = map[string]any{"drives": []map[string]string{{"id": "engineering", "name": "Engineering"}}}
+		case r.URL.Path == "/drive/v3/files":
+			if strings.Contains(r.URL.Query().Get("q"), "name contains") {
+				response = map[string]any{"files": folders}
+			} else {
+				response = map[string]any{"files": []any{}}
+			}
+		default:
+			var ok bool
+			response, ok = metadata[strings.TrimPrefix(r.URL.Path, "/drive/v3/files/")]
+			if !ok {
+				w.WriteHeader(http.StatusNotFound)
+				response = map[string]string{"error": "unavailable"}
+			}
+		}
+		json.NewEncoder(w).Encode(response)
+	})
+	log.Fatal(http.ListenAndServe(*addr, nil))
+}