fix: the Vaults sheet marks the open vault by its folder, and shows each vault's own name

Found while driving the same change on the iPhone simulator. The Vaults
sheet lists folders, and its rename and delete act on the folder, but it
marked the open vault by comparing an entry's folder name with the name the
shell snapshot shows. Once a vault carries a display name (ZenNotes
#692, core 2.56.x) those are different strings, so a renamed vault lost
its check mark, its row became tappable, and the manage view offered Delete
and Rename for the vault that was open.

The sheet now asks the bridge for the open vault's folder name
(`currentVaultFolderName`, the MobileVault it holds) and compares that,
the external-root clause unchanged; the snapshot's name is only what the
open vault's row shows. The other rows show the name each vault goes by,
read from its own vault.json (one small read per local or cloud folder, no
download wait for an evicted cloud file, which keeps its folder name), and
the manage view names the folder beside a display name that differs, so a
rename or delete is understood to act on the folder. `MobileVaultEntry`
gains `displayName`; `name` stays the folder, which every management call
keys on.

Author: adibhanna

src/bridge/mobile-bridge.ts

@@ -39,7 +39,7 @@ import type {
   VaultTextSearchMatch
 } from '@zennotes/shared-domain/ipc'
 import { createDatabaseOps } from '@zennotes/shared-domain/database-ops'
-import { resolveVaultName } from '@zennotes/shared-domain/vault-display-name'
+import { normalizeVaultDisplayName, resolveVaultName } from '@zennotes/shared-domain/vault-display-name'
 import type {
   CustomCodeLanguage,
   CustomCodeLanguageInstallInput,
@@ -62,6 +62,7 @@ import { MobileVault } from './vault-fs'
 import {
   listVaultDirs,
   readVaultDisplayName,
+  readVaultDisplayNameAtUrl,
   VAULTS_DIR,
   vaultsRoot,
   initVaultsRoot
@@ -182,7 +183,12 @@ export function currentExternalVaultRoot(): string | null {
 
 export interface MobileVaultEntry {
   root: string
+  /** The folder's name on disk: what rename and delete act on, and what the
+   *  open vault's `folderName` is compared with to mark it current. */
   name: string
+  /** The name the vault goes by when its vault.json carries one (ZenNotes
+   *  #692), normalized; the sheet shows it in place of the folder name. */
+  displayName?: string
   tier: 'local' | 'icloud' | 'external'
 }
 
@@ -226,17 +232,25 @@ async function looksLikeVaultDir(url: string): Promise<boolean> {
 export async function listSwitchableVaults(): Promise<MobileVaultEntry[]> {
   const out: MobileVaultEntry[] = []
   for (const d of await listVaultDirs()) {
-    out.push({ root: `${VAULT_ROOT_PREFIX}${d.name}`, name: d.name, tier: 'local' })
+    const displayName = normalizeVaultDisplayName(await readVaultDisplayName(d.name))
+    out.push({
+      root: `${VAULT_ROOT_PREFIX}${d.name}`,
+      name: d.name,
+      tier: 'local',
+      ...(displayName ? { displayName } : {})
+    })
   }
   const status = await icloudStatus().catch(() => null)
   if (status?.available && status.rootUrl) {
     for (const name of filterCloudVaultNames(status.vaults ?? [])) {
       const url = `${status.rootUrl}/${encodeURIComponent(name)}`
       if (!(await looksLikeVaultDir(url))) continue
+      const displayName = normalizeVaultDisplayName(await readVaultDisplayNameAtUrl(url))
       out.push({
         root: `${ICLOUD_VAULT_ROOT_PREFIX}${encodeURIComponent(name)}`,
         name,
-        tier: 'icloud'
+        tier: 'icloud',
+        ...(displayName ? { displayName } : {})
       })
     }
   }
@@ -458,6 +472,18 @@ function currentVaultInfo(): VaultInfo | null {
  * open, and a vault whose vault.json cannot be read keeps its folder name,
  * the way it always did.
  */
+/**
+ * The open local vault's folder name, null in a remote workspace or before
+ * boot. The Vaults sheet lists folders and must mark the one that is open
+ * whatever the vault is called (rename and delete act on the folder), and
+ * the core's shell snapshot carries the vault's shown name, not its folder,
+ * so the sheet asks the bridge, which holds the MobileVault by folder name.
+ */
+export function currentVaultFolderName(): string | null {
+  if (remoteVaultInfo()) return null
+  return vault?.name ?? null
+}
+
 async function describeCurrentVault(): Promise<VaultInfo | null> {
   const info = currentVaultInfo()
   if (!info || remoteVaultInfo() || !vault) return info

src/bridge/native-fs.ts

@@ -428,12 +428,25 @@ export async function listVaultDirs(): Promise<{ name: string; mtime: number }[]
  * folder name, the way desktop's describeVault does.
  */
 export async function readVaultDisplayName(vaultName: string): Promise<string | null> {
+  return readDisplayNameFrom({
+    path: `${VAULTS_DIR}/${vaultName}/.zennotes/vault.json`,
+    directory: vaultsRoot()
+  })
+}
+
+/**
+ * The same for a vault addressed by a file URL, which is how the cloud tier
+ * lists its vaults (see looksLikeVaultDir). One read attempt, no download
+ * wait: an evicted vault.json answers null and the vault keeps its folder
+ * name in the switcher, rather than every listing waiting on the cloud.
+ */
+export async function readVaultDisplayNameAtUrl(url: string): Promise<string | null> {
+  return readDisplayNameFrom({ path: `${url}/.zennotes/vault.json` })
+}
+
+async function readDisplayNameFrom(loc: { path: string; directory?: Directory }): Promise<string | null> {
   try {
-    const res = await Filesystem.readFile({
-      path: `${VAULTS_DIR}/${vaultName}/.zennotes/vault.json`,
-      directory: vaultsRoot(),
-      encoding: Encoding.UTF8
-    })
+    const res = await Filesystem.readFile({ ...loc, encoding: Encoding.UTF8 })
     const parsed: unknown = JSON.parse(typeof res.data === 'string' ? res.data : '')
     const name = (parsed as { displayName?: unknown } | null)?.displayName
     return typeof name === 'string' ? name : null

src/ui-mobile/MobileDrawer.tsx

@@ -32,6 +32,7 @@ import { getStoragePref } from '../bridge/icloud'
 import {
   ICLOUD_VAULT_ROOT_PREFIX,
   VAULT_ROOT_PREFIX,
+  currentVaultFolderName,
   listSwitchableVaults,
   renameVault,
   deleteVault,
@@ -280,7 +281,14 @@ const TIER_SECTIONS = [
 ] as const
 
 export function VaultsSheet({ onClose }: { onClose: () => void }): React.JSX.Element {
-  const currentName = useShellSnapshot().vault?.name ?? null
+  // The open vault is matched by its folder name, which is what an entry's
+  // `name` is: rename and delete act on the folder, so the guards below must
+  // hold for the folder that is open whatever the vault is called. The
+  // bridge names the folder; the snapshot's vault name is the display name
+  // (ZenNotes #692), which is what the rows show: the snapshot's for the
+  // open vault (the shell resolves it) and each entry's for the others.
+  const currentDisplayName = useShellSnapshot().vault?.name ?? null
+  const currentFolder = currentVaultFolderName()
   const { mode: workspaceMode, remoteProfileId, remoteProfiles } = useWorkspaceSnapshot()
   const [entries, setEntries] = useState<MobileVaultEntry[] | null>(null)
   const [view, setView] = useState<ManagerView>({ kind: 'list' })
@@ -305,9 +313,11 @@ export function VaultsSheet({ onClose }: { onClose: () => void }): React.JSX.Ele
   const currentTier = workspaceMode === 'remote' ? 'remote' : getStoragePref()
   const isCurrent = (e: MobileVaultEntry): boolean =>
     currentTier === e.tier &&
-    e.name === currentName &&
-    // Picked folders may share a display name — the root token decides.
+    e.name === currentFolder &&
+    // Picked folders may share a folder name: the root token decides.
     (e.tier !== 'external' || e.root === currentExternalVaultRoot())
+  const shownName = (e: MobileVaultEntry): string =>
+    (isCurrent(e) ? currentDisplayName : null) ?? e.displayName ?? e.name
 
   /** Switch flows close the sheet and drawer on success. */
   const act = (key: string, fn: () => Promise<unknown>): void => {
@@ -433,13 +443,13 @@ export function VaultsSheet({ onClose }: { onClose: () => void }): React.JSX.Ele
                                 )
                               }
                             >
-                              <span className="zn-truncate">{entry.name}</span>
+                              <span className="zn-truncate">{shownName(entry)}</span>
                               {current && <span className="zn-mobile-sheet-row-check">✓</span>}
                             </button>
                             <button
                               type="button"
                               className="zn-mobile-sheet-row-more"
-                              aria-label={`Manage ${entry.name}`}
+                              aria-label={`Manage ${shownName(entry)}`}
                               onClick={() => {
                                 setError('')
                                 setView({ kind: 'vault', entry })
@@ -523,7 +533,8 @@ export function VaultsSheet({ onClose }: { onClose: () => void }): React.JSX.Ele
             <>
               {backRow}
               <p className="zn-mobile-sheet-note">
-                “{view.entry.name}” —{' '}
+                “{shownName(view.entry)}”
+                {shownName(view.entry) !== view.entry.name ? ` (folder ${view.entry.name})` : ''},{' '}
                 {view.entry.tier === 'icloud'
                   ? 'iCloud Drive'
                   : view.entry.tier === 'external'