diff --git a/app/src/components/intelligence/VaultPanel.test.tsx b/app/src/components/intelligence/VaultPanel.test.tsx
index f000a767a..e4c72f5fb 100644
--- a/app/src/components/intelligence/VaultPanel.test.tsx
+++ b/app/src/components/intelligence/VaultPanel.test.tsx
@@ -11,12 +11,14 @@ import { VaultPanel } from './VaultPanel';
 const mockList = vi.fn();
 const mockCreate = vi.fn();
 const mockSync = vi.fn();
+const mockSyncStatus = vi.fn();
 const mockRemove = vi.fn();
 
 vi.mock('../../utils/tauriCommands/vault', () => ({
   openhumanVaultList: (...args: unknown[]) => mockList(...args),
   openhumanVaultCreate: (...args: unknown[]) => mockCreate(...args),
   openhumanVaultSync: (...args: unknown[]) => mockSync(...args),
+  openhumanVaultSyncStatus: (...args: unknown[]) => mockSyncStatus(...args),
   openhumanVaultRemove: (...args: unknown[]) => mockRemove(...args),
 }));
 
@@ -35,11 +37,35 @@ function vault(overrides: Record<string, unknown> = {}) {
   };
 }
 
+/** Build a completed `CoreVaultSyncState` payload for mockSyncStatus. */
+function syncState(overrides: Record<string, unknown> = {}) {
+  return {
+    result: {
+      vault_id: 'v-1',
+      status: 'completed',
+      scanned: 4,
+      ingested: 3,
+      unchanged: 1,
+      removed: 0,
+      failed: 0,
+      skipped_unsupported: 0,
+      total: 4,
+      started_at_ms: 1_000,
+      finished_at_ms: 2_200,
+      duration_ms: 1_200,
+      errors: [],
+      ...overrides,
+    },
+    logs: [],
+  };
+}
+
 describe('<VaultPanel />', () => {
   beforeEach(() => {
     mockList.mockReset();
     mockCreate.mockReset();
     mockSync.mockReset();
+    mockSyncStatus.mockReset();
     mockRemove.mockReset();
   });
 
@@ -133,20 +159,10 @@ describe('<VaultPanel />', () => {
     mockList
       .mockResolvedValueOnce({ result: [vault()], logs: [] })
       .mockResolvedValueOnce({ result: [vault()], logs: [] });
-    mockSync.mockResolvedValueOnce({
-      result: {
-        vault_id: 'v-1',
-        scanned: 4,
-        ingested: 3,
-        unchanged: 1,
-        removed: 0,
-        failed: 0,
-        skipped_unsupported: 0,
-        duration_ms: 1200,
-        errors: [],
-      },
-      logs: [],
-    });
+    // vault_sync returns immediately with "started"
+    mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
+    // vault_sync_status returns "completed" on first poll
+    mockSyncStatus.mockResolvedValueOnce(syncState());
     const onToast = vi.fn();
     render(<VaultPanel onToast={onToast} />);
     await waitFor(() => screen.getByTestId('vault-list'));
@@ -168,20 +184,16 @@ describe('<VaultPanel />', () => {
     mockList
       .mockResolvedValueOnce({ result: [vault()], logs: [] })
       .mockResolvedValueOnce({ result: [vault()], logs: [] });
-    mockSync.mockResolvedValueOnce({
-      result: {
-        vault_id: 'v-1',
-        scanned: 2,
+    mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
+    mockSyncStatus.mockResolvedValueOnce(
+      syncState({
         ingested: 1,
         unchanged: 0,
-        removed: 0,
         failed: 1,
-        skipped_unsupported: 0,
         duration_ms: 50,
         errors: ['x.md: read failed'],
-      },
-      logs: [],
-    });
+      })
+    );
     const onToast = vi.fn();
     render(<VaultPanel onToast={onToast} />);
     await waitFor(() => screen.getByTestId('vault-list'));
@@ -209,6 +221,110 @@ describe('<VaultPanel />', () => {
     );
   });
 
+  it('emits error toast when sync status returns failed', async () => {
+    mockList
+      .mockResolvedValueOnce({ result: [vault()], logs: [] })
+      .mockResolvedValueOnce({ result: [vault()], logs: [] });
+    mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
+    mockSyncStatus.mockResolvedValueOnce(
+      syncState({ status: 'failed', failed: 0, errors: ['disk full'] })
+    );
+    const onToast = vi.fn();
+    render(<VaultPanel onToast={onToast} />);
+    await waitFor(() => screen.getByTestId('vault-list'));
+
+    fireEvent.click(screen.getByText('Sync'));
+    await waitFor(() =>
+      expect(onToast).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'error',
+          title: expect.stringContaining('Sync failed'),
+          message: expect.stringContaining('disk full'),
+        })
+      )
+    );
+  });
+
+  it('emits error toast when status poll RPC throws', async () => {
+    mockList.mockResolvedValueOnce({ result: [vault()], logs: [] });
+    mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
+    mockSyncStatus.mockRejectedValueOnce(new Error('poll error'));
+    const onToast = vi.fn();
+    render(<VaultPanel onToast={onToast} />);
+    await waitFor(() => screen.getByTestId('vault-list'));
+
+    fireEvent.click(screen.getByText('Sync'));
+    await waitFor(() =>
+      expect(onToast).toHaveBeenCalledWith(
+        expect.objectContaining({ type: 'error', title: 'Sync failed', message: 'poll error' })
+      )
+    );
+  });
+
+  it('uses fallback failed-file count message when errors array is empty', async () => {
+    mockList
+      .mockResolvedValueOnce({ result: [vault()], logs: [] })
+      .mockResolvedValueOnce({ result: [vault()], logs: [] });
+    mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
+    mockSyncStatus.mockResolvedValueOnce(syncState({ status: 'failed', failed: 3, errors: [] }));
+    const onToast = vi.fn();
+    render(<VaultPanel onToast={onToast} />);
+    await waitFor(() => screen.getByTestId('vault-list'));
+
+    fireEvent.click(screen.getByText('Sync'));
+    await waitFor(() =>
+      expect(onToast).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'error',
+          message: expect.stringContaining('Failed 3 file(s)'),
+        })
+      )
+    );
+  });
+
+  it('includes skipped_unsupported count in completed toast message', async () => {
+    mockList
+      .mockResolvedValueOnce({ result: [vault()], logs: [] })
+      .mockResolvedValueOnce({ result: [vault()], logs: [] });
+    mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
+    mockSyncStatus.mockResolvedValueOnce(
+      syncState({ ingested: 2, skipped_unsupported: 5, duration_ms: 0 })
+    );
+    const onToast = vi.fn();
+    render(<VaultPanel onToast={onToast} />);
+    await waitFor(() => screen.getByTestId('vault-list'));
+
+    fireEvent.click(screen.getByText('Sync'));
+    await waitFor(() =>
+      expect(onToast).toHaveBeenCalledWith(
+        expect.objectContaining({ message: expect.stringContaining('skipped 5') })
+      )
+    );
+  });
+
+  it('cancels pending poll timer on unmount', async () => {
+    mockList.mockResolvedValueOnce({ result: [vault()], logs: [] });
+    mockSync.mockResolvedValueOnce({ result: { status: 'started', vault_id: 'v-1' }, logs: [] });
+    // Always running — the 1 500 ms re-poll timer stays live after poll #1.
+    mockSyncStatus.mockResolvedValue(syncState({ status: 'running', ingested: 1, total: 4 }));
+
+    const { unmount } = render(<VaultPanel />);
+    await waitFor(() => screen.getByTestId('vault-list'));
+
+    fireEvent.click(screen.getByText('Sync'));
+
+    // Wait until the first poll fires (0 ms timer) so the 1 500 ms next-poll
+    // timer is scheduled in pollTimers.current.
+    await waitFor(() => expect(mockSyncStatus).toHaveBeenCalledTimes(1));
+
+    const clearSpy = vi.spyOn(globalThis, 'clearTimeout');
+    unmount();
+
+    // useEffect cleanup must have called clearTimeout for the pending timer.
+    expect(clearSpy).toHaveBeenCalled();
+    clearSpy.mockRestore();
+  });
+
   it('removes a vault with purge=true when both confirms accepted', async () => {
     mockList
       .mockResolvedValueOnce({ result: [vault()], logs: [] })
diff --git a/app/src/components/intelligence/VaultPanel.tsx b/app/src/components/intelligence/VaultPanel.tsx
index c0fa760d9..488dc802c 100644
--- a/app/src/components/intelligence/VaultPanel.tsx
+++ b/app/src/components/intelligence/VaultPanel.tsx
@@ -3,18 +3,22 @@
  * files mirrored into memory under namespace `vault:<id>`. Sits inside
  * the Intelligence ▸ Memory tab.
  */
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 
 import type { ToastNotification } from '../../types/intelligence';
 import {
   type CoreVault,
-  type CoreVaultSyncReport,
+  type CoreVaultSyncState,
   openhumanVaultCreate,
   openhumanVaultList,
   openhumanVaultRemove,
   openhumanVaultSync,
+  openhumanVaultSyncStatus,
 } from '../../utils/tauriCommands/vault';
 
+/** How often the UI re-polls for sync progress while a sync is running (ms). */
+const SYNC_POLL_INTERVAL_MS = 1_500;
+
 interface VaultPanelProps {
   onToast?: (toast: Omit<ToastNotification, 'id'>) => void;
 }
@@ -24,12 +28,28 @@ export function VaultPanel({ onToast }: VaultPanelProps) {
   const [loading, setLoading] = useState(true);
   const [loadError, setLoadError] = useState<string | null>(null);
   const [busy, setBusy] = useState<Record<string, 'sync' | 'remove' | undefined>>({});
+  const [syncProgress, setSyncProgress] = useState<
+    Record<string, { ingested: number; total: number } | undefined>
+  >({});
   const [creating, setCreating] = useState(false);
   const [showForm, setShowForm] = useState(false);
   const [newName, setNewName] = useState('');
   const [newPath, setNewPath] = useState('');
   const [newExcludes, setNewExcludes] = useState('');
 
+  // Track active polling timers so we can cancel them on unmount.
+  const pollTimers = useRef<Record<string, ReturnType<typeof setTimeout>>>({});
+
+  // Cancel all active poll timers on unmount.
+  useEffect(() => {
+    const timers = pollTimers.current;
+    return () => {
+      for (const t of Object.values(timers)) {
+        clearTimeout(t);
+      }
+    };
+  }, []);
+
   const reload = useCallback(async () => {
     setLoading(true);
     setLoadError(null);
@@ -88,29 +108,99 @@ export function VaultPanel({ onToast }: VaultPanelProps) {
   const handleSync = useCallback(
     async (vault: CoreVault) => {
       setBusy(b => ({ ...b, [vault.id]: 'sync' }));
+      setSyncProgress(p => ({ ...p, [vault.id]: undefined }));
+
+      // Start the background sync.
       try {
-        const resp = await openhumanVaultSync(vault.id);
-        const r: CoreVaultSyncReport = resp.result;
-        onToast?.({
-          type: r.failed > 0 ? 'info' : 'success',
-          title: `Synced "${vault.name}"`,
-          message:
-            `Ingested ${r.ingested}, unchanged ${r.unchanged}, removed ${r.removed}` +
-            (r.failed > 0 ? `, failed ${r.failed}` : '') +
-            (r.skipped_unsupported > 0 ? `, skipped ${r.skipped_unsupported}` : '') +
-            ` · ${(r.duration_ms / 1000).toFixed(1)}s`,
-        });
-        await reload();
+        await openhumanVaultSync(vault.id);
       } catch (err) {
-        console.error('[ui-flow][vault-panel] sync failed', err);
+        console.error('[ui-flow][vault-panel] sync start failed', err);
         onToast?.({
           type: 'error',
           title: 'Sync failed',
           message: err instanceof Error ? err.message : String(err),
         });
-      } finally {
         setBusy(b => ({ ...b, [vault.id]: undefined }));
+        return;
       }
+
+      console.debug('[ui-flow][vault-panel] sync started, polling for status', {
+        vaultId: vault.id,
+      });
+
+      // Poll until the background task finishes.
+      const vaultId = vault.id;
+      const vaultName = vault.name;
+
+      const poll = async () => {
+        let st: CoreVaultSyncState;
+        try {
+          const resp = await openhumanVaultSyncStatus(vaultId);
+          st = resp.result;
+        } catch (err) {
+          console.error('[ui-flow][vault-panel] sync status poll failed', err);
+          setBusy(b => ({ ...b, [vaultId]: undefined }));
+          setSyncProgress(p => ({ ...p, [vaultId]: undefined }));
+          onToast?.({
+            type: 'error',
+            title: 'Sync failed',
+            message: err instanceof Error ? err.message : String(err),
+          });
+          return;
+        }
+
+        // Update progress indicator while running.
+        if (st.total > 0) {
+          setSyncProgress(p => ({ ...p, [vaultId]: { ingested: st.ingested, total: st.total } }));
+        }
+
+        console.debug('[ui-flow][vault-panel] sync poll', {
+          vaultId,
+          status: st.status,
+          ingested: st.ingested,
+          total: st.total,
+        });
+
+        if (st.status === 'completed' || st.status === 'failed') {
+          // Clear polling state and show final toast.
+          delete pollTimers.current[vaultId];
+          setBusy(b => ({ ...b, [vaultId]: undefined }));
+          setSyncProgress(p => ({ ...p, [vaultId]: undefined }));
+
+          if (st.status === 'failed') {
+            onToast?.({
+              type: 'error',
+              title: `Sync failed for "${vaultName}"`,
+              message:
+                st.errors.length > 0
+                  ? st.errors.slice(0, 3).join('; ')
+                  : `Failed ${st.failed} file(s)`,
+            });
+          } else {
+            onToast?.({
+              type: st.failed > 0 ? 'info' : 'success',
+              title: `Synced "${vaultName}"`,
+              message:
+                `Ingested ${st.ingested}, unchanged ${st.unchanged}, removed ${st.removed}` +
+                (st.failed > 0 ? `, failed ${st.failed}` : '') +
+                (st.skipped_unsupported > 0 ? `, skipped ${st.skipped_unsupported}` : '') +
+                (st.duration_ms > 0 ? ` · ${(st.duration_ms / 1000).toFixed(1)}s` : ''),
+            });
+          }
+          await reload();
+          return;
+        }
+
+        // Still running — schedule the next poll.
+        pollTimers.current[vaultId] = setTimeout(() => {
+          void poll();
+        }, SYNC_POLL_INTERVAL_MS);
+      };
+
+      // First poll fires immediately (0 ms delay) so tests don't need fake timers.
+      pollTimers.current[vaultId] = setTimeout(() => {
+        void poll();
+      }, 0);
     },
     [onToast, reload]
   );
@@ -272,7 +362,11 @@ export function VaultPanel({ onToast }: VaultPanelProps) {
                     className="rounded-md border border-primary-300 bg-white dark:bg-neutral-900 px-3 py-1.5 text-xs
                                font-semibold text-primary-700 dark:text-primary-300 shadow-sm transition-colors
                                hover:bg-primary-50 dark:hover:bg-primary-500/15 disabled:cursor-not-allowed disabled:opacity-50">
-                    {state === 'sync' ? 'Syncing…' : 'Sync'}
+                    {state === 'sync'
+                      ? (syncProgress[v.id]?.total ?? 0) > 0
+                        ? `Syncing… ${syncProgress[v.id]!.ingested}/${syncProgress[v.id]!.total}`
+                        : 'Syncing…'
+                      : 'Sync'}
                   </button>
                   <button
                     type="button"
diff --git a/app/src/utils/tauriCommands/vault.test.ts b/app/src/utils/tauriCommands/vault.test.ts
index b2d7d116d..39d4429e4 100644
--- a/app/src/utils/tauriCommands/vault.test.ts
+++ b/app/src/utils/tauriCommands/vault.test.ts
@@ -23,6 +23,7 @@ describe('tauriCommands/vault', () => {
   let openhumanVaultFiles: typeof import('./vault').openhumanVaultFiles;
   let openhumanVaultRemove: typeof import('./vault').openhumanVaultRemove;
   let openhumanVaultSync: typeof import('./vault').openhumanVaultSync;
+  let openhumanVaultSyncStatus: typeof import('./vault').openhumanVaultSyncStatus;
 
   beforeEach(async () => {
     vi.clearAllMocks();
@@ -34,6 +35,7 @@ describe('tauriCommands/vault', () => {
     openhumanVaultFiles = actual.openhumanVaultFiles;
     openhumanVaultRemove = actual.openhumanVaultRemove;
     openhumanVaultSync = actual.openhumanVaultSync;
+    openhumanVaultSyncStatus = actual.openhumanVaultSyncStatus;
   });
 
   afterEach(() => {
@@ -162,19 +164,9 @@ describe('tauriCommands/vault', () => {
       await expect(openhumanVaultSync('v-1')).rejects.toThrow('Not running in Tauri');
     });
 
-    test('dispatches openhuman.vault_sync with vault_id and returns report', async () => {
+    test('dispatches openhuman.vault_sync with vault_id and returns started status', async () => {
       mockCallCoreRpc.mockResolvedValue({
-        result: {
-          vault_id: 'v-1',
-          scanned: 3,
-          ingested: 2,
-          unchanged: 1,
-          removed: 0,
-          failed: 0,
-          skipped_unsupported: 0,
-          duration_ms: 12,
-          errors: [],
-        },
+        result: { status: 'started', vault_id: 'v-1' },
         logs: [],
       });
       const resp = await openhumanVaultSync('v-1');
@@ -182,7 +174,44 @@ describe('tauriCommands/vault', () => {
         method: 'openhuman.vault_sync',
         params: { vault_id: 'v-1' },
       });
-      expect(resp.result.ingested).toBe(2);
+      expect(resp.result.status).toBe('started');
+      expect(resp.result.vault_id).toBe('v-1');
+    });
+  });
+
+  describe('openhumanVaultSyncStatus', () => {
+    test('throws when not running in Tauri', async () => {
+      mockIsTauri.mockReturnValue(false);
+      await expect(openhumanVaultSyncStatus('v-1')).rejects.toThrow('Not running in Tauri');
+      expect(mockCallCoreRpc).not.toHaveBeenCalled();
+    });
+
+    test('dispatches openhuman.vault_sync_status with vault_id', async () => {
+      mockCallCoreRpc.mockResolvedValue({
+        result: {
+          vault_id: 'v-1',
+          status: 'completed',
+          scanned: 4,
+          ingested: 4,
+          unchanged: 0,
+          removed: 0,
+          failed: 0,
+          skipped_unsupported: 0,
+          total: 4,
+          started_at_ms: 1000,
+          finished_at_ms: 2000,
+          duration_ms: 1000,
+          errors: [],
+        },
+        logs: [],
+      });
+      const resp = await openhumanVaultSyncStatus('v-1');
+      expect(mockCallCoreRpc).toHaveBeenCalledWith({
+        method: 'openhuman.vault_sync_status',
+        params: { vault_id: 'v-1' },
+      });
+      expect(resp.result.status).toBe('completed');
+      expect(resp.result.vault_id).toBe('v-1');
     });
   });
 });
diff --git a/app/src/utils/tauriCommands/vault.ts b/app/src/utils/tauriCommands/vault.ts
index ca3e5e87b..496ac97d1 100644
--- a/app/src/utils/tauriCommands/vault.ts
+++ b/app/src/utils/tauriCommands/vault.ts
@@ -29,14 +29,23 @@ export interface CoreVaultFile {
   status: CoreVaultFileStatus;
 }
 
-export interface CoreVaultSyncReport {
+export type CoreVaultSyncStatus = 'idle' | 'running' | 'completed' | 'failed';
+
+/** Live progress returned by `openhuman.vault_sync_status`. */
+export interface CoreVaultSyncState {
   vault_id: string;
+  status: CoreVaultSyncStatus;
   scanned: number;
   ingested: number;
   unchanged: number;
   removed: number;
   failed: number;
   skipped_unsupported: number;
+  /** Total files queued for ingestion; 0 while the discovery walk is still running. */
+  total: number;
+  started_at_ms: number;
+  finished_at_ms: number | null;
+  /** Wall-clock ms; 0 while running; set on completion. */
   duration_ms: number;
   errors: string[];
 }
@@ -100,10 +109,21 @@ export async function openhumanVaultRemove(
 
 export async function openhumanVaultSync(
   vaultId: string
-): Promise<CommandResponse<CoreVaultSyncReport>> {
+): Promise<CommandResponse<{ status: string; vault_id: string }>> {
   ensureTauri();
-  return await callCoreRpc<CommandResponse<CoreVaultSyncReport>>({
+  return await callCoreRpc<CommandResponse<{ status: string; vault_id: string }>>({
     method: 'openhuman.vault_sync',
     params: { vault_id: vaultId },
   });
 }
+
+/** Poll live sync progress for a vault. */
+export async function openhumanVaultSyncStatus(
+  vaultId: string
+): Promise<CommandResponse<CoreVaultSyncState>> {
+  ensureTauri();
+  return await callCoreRpc<CommandResponse<CoreVaultSyncState>>({
+    method: 'openhuman.vault_sync_status',
+    params: { vault_id: vaultId },
+  });
+}
diff --git a/src/openhuman/vault/mod.rs b/src/openhuman/vault/mod.rs
index fb85410ac..b0a3462ea 100644
--- a/src/openhuman/vault/mod.rs
+++ b/src/openhuman/vault/mod.rs
@@ -7,6 +7,7 @@
 
 pub mod ops;
 mod schemas;
+pub(crate) mod state;
 mod store;
 mod sync;
 mod types;
@@ -15,7 +16,9 @@ pub use schemas::{
     all_controller_schemas as all_vault_controller_schemas,
     all_registered_controllers as all_vault_registered_controllers,
 };
-pub use types::{Vault, VaultFile, VaultFileStatus, VaultSyncReport};
+pub use types::{
+    Vault, VaultFile, VaultFileStatus, VaultSyncReport, VaultSyncState, VaultSyncStatus,
+};
 
 #[cfg(test)]
 mod tests;
diff --git a/src/openhuman/vault/ops.rs b/src/openhuman/vault/ops.rs
index 0e2a1057e..774356f1d 100644
--- a/src/openhuman/vault/ops.rs
+++ b/src/openhuman/vault/ops.rs
@@ -1,15 +1,17 @@
 //! RPC-facing operations for the vault domain.
 
 use chrono::Utc;
+use futures::FutureExt;
 use uuid::Uuid;
 
 use crate::openhuman::config::Config;
 use crate::openhuman::memory::ops::{clear_namespace, ClearNamespaceParams};
 use crate::rpc::RpcOutcome;
 
+use super::state;
 use super::store;
 use super::sync;
-use super::types::{Vault, VaultFile, VaultSyncReport};
+use super::types::{Vault, VaultFile, VaultSyncState, VaultSyncStatus};
 
 /// Create a new vault pointing at a local folder.
 pub async fn vault_create(
@@ -139,8 +141,16 @@ pub async fn vault_remove(
     ))
 }
 
-/// Trigger an immediate sync of a vault. Blocks until complete.
-pub async fn vault_sync(config: &Config, id: &str) -> Result<RpcOutcome<VaultSyncReport>, String> {
+/// Trigger a vault sync as a background task and return immediately.
+///
+/// The caller should poll `vault_sync_status` to track progress and retrieve
+/// the final outcome.  Returns an error if a sync is already running for this
+/// vault so the caller can surface a user-friendly message instead of silently
+/// queuing a duplicate.
+pub async fn vault_sync(
+    config: &Config,
+    id: &str,
+) -> Result<RpcOutcome<serde_json::Value>, String> {
     let id = id.trim();
     if id.is_empty() {
         return Err("vault_id must not be empty".to_string());
@@ -148,21 +158,109 @@ pub async fn vault_sync(config: &Config, id: &str) -> Result<RpcOutcome<VaultSyn
     let vault = store::get_vault(config, id)
         .map_err(|e| e.to_string())?
         .ok_or_else(|| format!("vault not found: {id}"))?;
-    log::debug!("[vault] sync: entry id={id} root={:?}", vault.root_path);
-    let report = sync::sync_vault(config, &vault).await;
+
+    // Register in the state map; returns Err if already running.
+    let started_at_ms = Utc::now().timestamp_millis();
+    state::start(id, started_at_ms).map_err(|e| format!("sync already in progress: {e}"))?;
+
     log::debug!(
-        "[vault] sync: exit id={id} scanned={} ingested={} unchanged={} removed={} failed={} skipped={} duration_ms={}",
-        report.scanned,
-        report.ingested,
-        report.unchanged,
-        report.removed,
-        report.failed,
-        report.skipped_unsupported,
-        report.duration_ms,
+        "[vault] sync: background task spawned id={id} root={:?}",
+        vault.root_path,
     );
-    let msg = format!(
-        "vault sync done — ingested {}, unchanged {}, removed {}, failed {}",
-        report.ingested, report.unchanged, report.removed, report.failed
+
+    // Clone what the background task needs — Config is Clone (derives it).
+    let config_clone = config.clone();
+    let vault_id = id.to_string();
+
+    tokio::spawn(async move {
+        log::debug!("[vault] sync: background task running id={vault_id}");
+
+        // Wrap the work in catch_unwind so a panic inside sync_vault cannot leave
+        // the vault state permanently stuck in `Running`.  Without this guard a
+        // panic would unwind the task, the state map entry would never be updated,
+        // and every subsequent sync attempt would be rejected with "already in progress"
+        // until the app is restarted.
+        let result =
+            std::panic::AssertUnwindSafe(async { sync::sync_vault(&config_clone, &vault).await })
+                .catch_unwind()
+                .await;
+
+        match result {
+            Ok(report) => {
+                let success = report.failed == 0;
+                let finished_at_ms = Utc::now().timestamp_millis();
+
+                // Write final counters back into the state map.
+                state::update_progress(&vault_id, |s| {
+                    s.status = if success {
+                        VaultSyncStatus::Completed
+                    } else {
+                        VaultSyncStatus::Failed
+                    };
+                    s.finished_at_ms = Some(finished_at_ms);
+                    s.ingested = report.ingested;
+                    s.unchanged = report.unchanged;
+                    s.removed = report.removed;
+                    s.failed = report.failed;
+                    s.skipped_unsupported = report.skipped_unsupported;
+                    s.scanned = report.scanned;
+                    s.duration_ms = report.duration_ms;
+                    s.errors = report.errors.clone();
+                });
+
+                log::debug!(
+                    "[vault] sync: background task done id={vault_id} ingested={} failed={} duration_ms={}",
+                    report.ingested,
+                    report.failed,
+                    report.duration_ms,
+                );
+            }
+            Err(_) => {
+                log::error!(
+                    "[vault] sync: background task panicked id={vault_id} — marking state as Failed"
+                );
+                state::update_progress(&vault_id, |s| {
+                    s.status = VaultSyncStatus::Failed;
+                    s.errors = vec!["sync task panicked unexpectedly".to_string()];
+                });
+            }
+        }
+    });
+
+    Ok(RpcOutcome::single_log(
+        serde_json::json!({ "status": "started", "vault_id": id }),
+        format!("vault sync started in background: {id}"),
+    ))
+}
+
+/// Return the current sync progress for a vault.
+///
+/// Returns an `Idle` state if no sync has ever run for this vault.
+pub async fn vault_sync_status(id: &str) -> Result<RpcOutcome<VaultSyncState>, String> {
+    let id = id.trim();
+    if id.is_empty() {
+        return Err("vault_id must not be empty".to_string());
+    }
+    let st = state::get(id).unwrap_or_else(|| VaultSyncState {
+        vault_id: id.to_string(),
+        status: VaultSyncStatus::Idle,
+        scanned: 0,
+        ingested: 0,
+        unchanged: 0,
+        removed: 0,
+        failed: 0,
+        skipped_unsupported: 0,
+        total: 0,
+        started_at_ms: 0,
+        finished_at_ms: None,
+        duration_ms: 0,
+        errors: vec![],
+    });
+    log::debug!(
+        "[vault] sync_status: id={id} status={:?} ingested={} total={}",
+        st.status,
+        st.ingested,
+        st.total,
     );
-    Ok(RpcOutcome::single_log(report, msg))
+    Ok(RpcOutcome::single_log(st, "vault sync status"))
 }
diff --git a/src/openhuman/vault/schemas.rs b/src/openhuman/vault/schemas.rs
index efc2b635d..b1b683e59 100644
--- a/src/openhuman/vault/schemas.rs
+++ b/src/openhuman/vault/schemas.rs
@@ -23,6 +23,7 @@ pub fn all_controller_schemas() -> Vec<ControllerSchema> {
         schemas("files"),
         schemas("remove"),
         schemas("sync"),
+        schemas("sync_status"),
     ]
 }
 
@@ -52,6 +53,10 @@ pub fn all_registered_controllers() -> Vec<RegisteredController> {
             schema: schemas("sync"),
             handler: handle_sync,
         },
+        RegisteredController {
+            schema: schemas("sync_status"),
+            handler: handle_sync_status,
+        },
     ]
 }
 
@@ -184,12 +189,32 @@ pub fn schemas(function: &str) -> ControllerSchema {
         "sync" => ControllerSchema {
             namespace: "vault",
             function: "sync",
-            description: "Walk a vault's root folder and ingest changed files.",
+            description: "Start a background sync of a vault's root folder. Returns immediately. Poll `vault.sync_status` for progress.",
             inputs: vec![vault_id_input("Identifier of the vault to sync.")],
+            outputs: vec![
+                FieldSchema {
+                    name: "status",
+                    ty: TypeSchema::String,
+                    comment: "Always `\"started\"` on success.",
+                    required: true,
+                },
+                FieldSchema {
+                    name: "vault_id",
+                    ty: TypeSchema::String,
+                    comment: "The vault that started syncing.",
+                    required: true,
+                },
+            ],
+        },
+        "sync_status" => ControllerSchema {
+            namespace: "vault",
+            function: "sync_status",
+            description: "Return the current sync progress and outcome for a vault.",
+            inputs: vec![vault_id_input("Identifier of the vault to query.")],
             outputs: vec![FieldSchema {
-                name: "report",
-                ty: TypeSchema::Ref("VaultSyncReport"),
-                comment: "Summary of the sync run.",
+                name: "state",
+                ty: TypeSchema::Ref("VaultSyncState"),
+                comment: "Current sync state (Idle / Running / Completed / Failed).",
                 required: true,
             }],
         },
@@ -278,6 +303,13 @@ fn handle_sync(params: Map<String, Value>) -> ControllerFuture {
     })
 }
 
+fn handle_sync_status(params: Map<String, Value>) -> ControllerFuture {
+    Box::pin(async move {
+        let vault_id = read_required::<String>(&params, "vault_id")?;
+        to_json(crate::openhuman::vault::ops::vault_sync_status(vault_id.trim()).await?)
+    })
+}
+
 fn read_required<T: DeserializeOwned>(params: &Map<String, Value>, key: &str) -> Result<T, String> {
     let value = params
         .get(key)
diff --git a/src/openhuman/vault/state.rs b/src/openhuman/vault/state.rs
new file mode 100644
index 000000000..cbec48340
--- /dev/null
+++ b/src/openhuman/vault/state.rs
@@ -0,0 +1,80 @@
+//! Global in-memory registry for vault sync progress state.
+//!
+//! State is keyed by `vault_id` and lives for the lifetime of the process.
+//! A completed/failed entry is retained until the next sync for the same
+//! vault overwrites it, so the frontend can always read the last outcome.
+//!
+//! Uses `once_cell::sync::Lazy` + `parking_lot::RwLock` — no heap allocation
+//! at import time, no `std::sync::Mutex` poisoning risk.
+
+use std::collections::HashMap;
+
+use once_cell::sync::Lazy;
+use parking_lot::RwLock;
+
+use super::types::{VaultSyncState, VaultSyncStatus};
+
+static SYNC_STATE: Lazy<RwLock<HashMap<String, VaultSyncState>>> =
+    Lazy::new(|| RwLock::new(HashMap::new()));
+
+/// Return the current sync state for a vault, or `None` if no sync has run.
+pub fn get(vault_id: &str) -> Option<VaultSyncState> {
+    SYNC_STATE.read().get(vault_id).cloned()
+}
+
+/// Replace the sync state for a vault (creates or overwrites the entry).
+pub fn set(state: VaultSyncState) {
+    SYNC_STATE.write().insert(state.vault_id.clone(), state);
+}
+
+/// Transition a vault to `Running`.
+///
+/// Returns `Err` if a sync for this vault is already in progress so the
+/// caller can reject duplicate requests.
+pub fn start(vault_id: &str, started_at_ms: i64) -> Result<(), String> {
+    let mut map = SYNC_STATE.write();
+    if let Some(s) = map.get(vault_id) {
+        if s.status == VaultSyncStatus::Running {
+            log::debug!(
+                "[vault][state] start rejected: vault_id={vault_id} already running since={}",
+                s.started_at_ms
+            );
+            return Err(format!("vault {vault_id} is already syncing"));
+        }
+    }
+    log::debug!("[vault][state] start: vault_id={vault_id} started_at_ms={started_at_ms}");
+    map.insert(
+        vault_id.to_string(),
+        VaultSyncState {
+            vault_id: vault_id.to_string(),
+            status: VaultSyncStatus::Running,
+            scanned: 0,
+            ingested: 0,
+            unchanged: 0,
+            removed: 0,
+            failed: 0,
+            skipped_unsupported: 0,
+            total: 0,
+            started_at_ms,
+            finished_at_ms: None,
+            duration_ms: 0,
+            errors: vec![],
+        },
+    );
+    Ok(())
+}
+
+/// Apply `f` to the current `VaultSyncState` for `vault_id` in-place.
+///
+/// No-ops silently if no entry exists (e.g. if the registry was cleared or
+/// the vault_id is wrong — neither should happen in normal operation).
+pub fn update_progress(vault_id: &str, f: impl FnOnce(&mut VaultSyncState)) {
+    let mut map = SYNC_STATE.write();
+    if let Some(s) = map.get_mut(vault_id) {
+        f(s);
+    } else {
+        log::debug!(
+            "[vault][state] update_progress no-op: vault_id={vault_id} not found in state map"
+        );
+    }
+}
diff --git a/src/openhuman/vault/sync.rs b/src/openhuman/vault/sync.rs
index 3a47d4e43..5e14fa3a5 100644
--- a/src/openhuman/vault/sync.rs
+++ b/src/openhuman/vault/sync.rs
@@ -4,12 +4,14 @@ use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 
 use chrono::Utc;
+use futures::StreamExt;
 use sha2::{Digest, Sha256};
 use walkdir::WalkDir;
 
 use crate::openhuman::config::Config;
 use crate::openhuman::memory::ops::{doc_delete, doc_ingest, DeleteDocParams, IngestDocParams};
 
+use super::state;
 use super::store;
 use super::types::{Vault, VaultFile, VaultFileStatus, VaultSyncReport};
 
@@ -32,6 +34,13 @@ const BUILTIN_EXCLUDE_DIRS: &[&str] = &[
 /// Max single-file size we read into memory for ingestion (5 MiB).
 const MAX_FILE_BYTES: u64 = 5 * 1024 * 1024;
 
+/// Number of files to ingest concurrently.
+///
+/// Bounded to avoid overwhelming the embedding API while still parallelising
+/// the dominant network cost.  Matches the codebase's existing `buffer_unordered`
+/// patterns (see `extract_tool.rs` and `cron/scheduler.rs`).
+const SYNC_CONCURRENCY: usize = 4;
+
 /// File extensions we currently extract as plain UTF-8.
 pub fn supported_extension(ext: &str) -> bool {
     matches!(
@@ -73,6 +82,103 @@ pub fn supported_extension(ext: &str) -> bool {
     )
 }
 
+/// A file that survived discovery and needs content read + ingestion.
+struct FileToProcess {
+    rel_path: String,
+    title: String,
+    path: PathBuf,
+    mtime_ms: i64,
+    bytes: u64,
+    ext: String,
+    /// Content hash from the previous successful sync, for secondary dedup.
+    prev_hash: Option<String>,
+    /// Document ID to update on re-ingest (keeps embedding lineage stable).
+    existing_doc_id: Option<String>,
+    /// Memory namespace (`vault:<id>`).
+    namespace: String,
+    /// Vault id for tags and state updates.
+    vault_id: String,
+}
+
+/// Outcome of attempting to ingest one file.
+enum IngestFileResult {
+    Ingested {
+        rel_path: String,
+        document_id: String,
+        hash: String,
+        mtime_ms: i64,
+        bytes: u64,
+    },
+    /// Content was read but the hash matched the previous ingest — skip ledger write.
+    Unchanged {
+        rel_path: String,
+    },
+    Failed {
+        rel_path: String,
+        error: String,
+    },
+}
+
+/// Read `file.path`, hash it, and call `doc_ingest` if the content changed.
+///
+/// This runs inside `buffer_unordered` so multiple files are in flight at once.
+async fn process_file(file: FileToProcess) -> IngestFileResult {
+    let content = match tokio::fs::read_to_string(&file.path).await {
+        Ok(c) => c,
+        Err(err) => {
+            return IngestFileResult::Failed {
+                rel_path: file.rel_path,
+                error: format!("read failed: {err}"),
+            };
+        }
+    };
+    let hash = sha256_hex(&content);
+
+    // Secondary dedup: content didn't change even if mtime did (e.g. `touch`).
+    if file.prev_hash.as_deref() == Some(hash.as_str()) {
+        return IngestFileResult::Unchanged {
+            rel_path: file.rel_path,
+        };
+    }
+
+    let ingest_params = IngestDocParams {
+        namespace: file.namespace,
+        key: file.rel_path.clone(),
+        title: file.title,
+        content,
+        source_type: "vault".to_string(),
+        priority: "medium".to_string(),
+        tags: vec![
+            format!("vault:{}", file.vault_id),
+            format!("ext:{}", file.ext),
+        ],
+        metadata: serde_json::json!({
+            "vault_id": file.vault_id,
+            "rel_path": file.rel_path,
+            "mtime_ms": file.mtime_ms,
+            "bytes": file.bytes,
+        }),
+        category: "user".to_string(),
+        session_id: None,
+        document_id: file.existing_doc_id,
+        config: None,
+    };
+
+    match doc_ingest(ingest_params).await {
+        Ok(outcome) => IngestFileResult::Ingested {
+            rel_path: file.rel_path,
+            document_id: outcome.value.document_id,
+            hash,
+            mtime_ms: file.mtime_ms,
+            bytes: file.bytes,
+        },
+        Err(err) => IngestFileResult::Failed {
+            rel_path: file.rel_path,
+            error: err,
+        },
+    }
+}
+
 /// Walk `vault.root_path`, ingest new/changed files into memory, delete docs
 /// whose source files vanished, and record per-file state in the ledger.
 pub async fn sync_vault(config: &Config, vault: &Vault) -> VaultSyncReport {
@@ -117,7 +223,7 @@ pub async fn sync_vault(config: &Config, vault: &Vault) -> VaultSyncReport {
         .collect();
 
     log::debug!(
-        "[vault] sync_vault: entry id={} root={:?} ledger_rows={} includes={} excludes={}",
+        "[vault] sync: entry id={} root={:?} ledger_rows={} includes={} excludes={}",
         vault.id,
         vault.root_path,
         existing.len(),
@@ -140,11 +246,14 @@ pub async fn sync_vault(config: &Config, vault: &Vault) -> VaultSyncReport {
                 .unwrap_or(true)
         });
 
+    // ── Phase 1: Discovery (sequential, no content reads) ───────────────────
+    let mut candidates: Vec<FileToProcess> = Vec::new();
+
     for entry in walker {
         let entry = match entry {
             Ok(e) => e,
             Err(err) => {
-                log::debug!("[vault] sync_vault: walk error err={err}");
+                log::debug!("[vault] sync: walk error err={err}");
                 report.errors.push(format!("walk error: {err}"));
                 continue;
             }
@@ -182,7 +291,7 @@ pub async fn sync_vault(config: &Config, vault: &Vault) -> VaultSyncReport {
             .to_string();
         if !supported_extension(&ext) {
             report.skipped_unsupported += 1;
-            seen.insert(rel_path.clone()); // keep ledger entries pruned
+            seen.insert(rel_path.clone());
             continue;
         }
 
@@ -199,9 +308,8 @@ pub async fn sync_vault(config: &Config, vault: &Vault) -> VaultSyncReport {
         if metadata.len() > MAX_FILE_BYTES {
             report.skipped_unsupported += 1;
             report.errors.push(format!(
-                "{rel_path}: skipped — {} bytes exceeds {}",
-                metadata.len(),
-                MAX_FILE_BYTES
+                "{rel_path}: skipped — {} bytes exceeds {MAX_FILE_BYTES}",
+                metadata.len()
             ));
             seen.insert(rel_path.clone());
             continue;
@@ -214,92 +322,108 @@ pub async fn sync_vault(config: &Config, vault: &Vault) -> VaultSyncReport {
             .map(|d| d.as_millis() as i64)
             .unwrap_or(0);
 
-        let content = match std::fs::read_to_string(path) {
-            Ok(c) => c,
-            Err(err) => {
-                report.failed += 1;
-                report
-                    .errors
-                    .push(format!("{rel_path}: read failed: {err}"));
-                continue;
-            }
-        };
-        let hash = sha256_hex(&content);
-
         seen.insert(rel_path.clone());
 
-        // Dedup: if hash and mtime unchanged, skip ingest.
+        // Fast-path mtime dedup: if both mtime and previous hash matched we can
+        // skip content reads entirely.  The concurrent phase does a secondary
+        // hash-based check for files whose mtime changed but content didn't.
         if let Some(prev) = by_path.get(&rel_path) {
-            if prev.status == VaultFileStatus::Ok
-                && prev.content_hash == hash
-                && prev.mtime_ms == mtime_ms
-            {
+            if prev.status == VaultFileStatus::Ok && prev.mtime_ms == mtime_ms {
                 report.unchanged += 1;
                 continue;
             }
         }
 
-        let key = rel_path.clone();
         let title = path
             .file_name()
             .and_then(|s| s.to_str())
             .unwrap_or(&rel_path)
             .to_string();
-        let ingest_params = IngestDocParams {
-            namespace: vault.namespace.clone(),
-            key,
-            title,
-            content,
-            source_type: "vault".to_string(),
-            priority: "medium".to_string(),
-            tags: vec![format!("vault:{}", vault.id), format!("ext:{ext}")],
-            metadata: serde_json::json!({
-                "vault_id": vault.id,
-                "rel_path": rel_path,
-                "mtime_ms": mtime_ms,
-                "bytes": metadata.len(),
-            }),
-            category: "user".to_string(),
-            session_id: None,
-            document_id: by_path.get(&rel_path).map(|p| p.document_id.clone()),
-            config: None,
-        };
+        let prev = by_path.get(&rel_path);
 
-        match doc_ingest(ingest_params).await {
-            Ok(outcome) => {
-                let document_id = outcome.value.document_id.clone();
+        candidates.push(FileToProcess {
+            rel_path,
+            title,
+            path: path.to_path_buf(),
+            mtime_ms,
+            bytes: metadata.len(),
+            ext,
+            prev_hash: prev.map(|p| p.content_hash.clone()),
+            existing_doc_id: prev.map(|p| p.document_id.clone()),
+            namespace: vault.namespace.clone(),
+            vault_id: vault.id.clone(),
+        });
+    }
+
+    log::debug!(
+        "[vault] sync: discovery done id={} scanned={} unchanged={} to_ingest={}",
+        vault.id,
+        report.scanned,
+        report.unchanged,
+        candidates.len(),
+    );
+
+    // Update shared state with total count so the frontend can show progress.
+    state::update_progress(&vault.id, |s| {
+        s.scanned = report.scanned;
+        s.unchanged = report.unchanged;
+        s.total = candidates.len() as u64;
+    });
+
+    // ── Phase 2: Concurrent ingestion ────────────────────────────────────────
+    let results: Vec<IngestFileResult> = futures::stream::iter(candidates)
+        .map(process_file)
+        .buffer_unordered(SYNC_CONCURRENCY)
+        .collect()
+        .await;
+
+    // ── Phase 3: Process results (sequential ledger writes) ──────────────────
+    for result in results {
+        match result {
+            IngestFileResult::Ingested {
+                rel_path,
+                document_id,
+                hash,
+                mtime_ms,
+                bytes,
+            } => {
                 let file = VaultFile {
                     vault_id: vault.id.clone(),
                     rel_path: rel_path.clone(),
                     document_id,
                     content_hash: hash,
                     mtime_ms,
-                    bytes: metadata.len(),
+                    bytes,
                     ingested_at: Utc::now(),
                     status: VaultFileStatus::Ok,
                 };
                 if let Err(err) = store::upsert_file(config, &file) {
-                    log::debug!(
-                        "[vault] sync_vault: ledger write failed path={rel_path} err={err}"
-                    );
+                    log::debug!("[vault] sync: ledger write failed path={rel_path} err={err}");
                     report
                         .errors
                         .push(format!("{rel_path}: ledger write failed: {err}"));
                 }
-                log::trace!("[vault] sync_vault: ingested path={rel_path}");
+                log::trace!("[vault] sync: ingested path={rel_path}");
                 report.ingested += 1;
+                state::update_progress(&vault.id, |s| s.ingested += 1);
             }
-            Err(err) => {
-                log::debug!("[vault] sync_vault: ingest failed path={rel_path} err={err}");
+            IngestFileResult::Unchanged { rel_path } => {
+                // Hash matched even though mtime changed — still a no-op.
+                log::trace!("[vault] sync: hash-unchanged path={rel_path}");
+                report.unchanged += 1;
+            }
+            IngestFileResult::Failed { rel_path, error } => {
+                log::debug!("[vault] sync: ingest failed path={rel_path} err={error}");
                 report.failed += 1;
                 report
                     .errors
-                    .push(format!("{rel_path}: ingest failed: {err}"));
+                    .push(format!("{rel_path}: ingest failed: {error}"));
+                state::update_progress(&vault.id, |s| s.failed += 1);
             }
         }
     }
 
-    // Anything in ledger we didn't see this pass is gone — delete it.
+    // ── Phase 4: Deletions ────────────────────────────────────────────────────
     for (path, prev) in by_path.iter() {
         if seen.contains(path) {
             continue;
@@ -310,28 +434,29 @@ pub async fn sync_vault(config: &Config, vault: &Vault) -> VaultSyncReport {
         })
         .await
         {
-            log::debug!("[vault] sync_vault: doc delete failed path={path} err={err}");
+            log::debug!("[vault] sync: doc delete failed path={path} err={err}");
             report
                 .errors
                 .push(format!("{path}: doc delete failed: {err}"));
             continue;
         }
         if let Err(err) = store::delete_file(config, &vault.id, path) {
-            log::debug!("[vault] sync_vault: ledger delete failed path={path} err={err}");
+            log::debug!("[vault] sync: ledger delete failed path={path} err={err}");
             report
                 .errors
                 .push(format!("{path}: ledger delete failed: {err}"));
             continue;
         }
         report.removed += 1;
+        state::update_progress(&vault.id, |s| s.removed += 1);
     }
 
     if let Err(err) = store::touch_last_synced(config, &vault.id, Utc::now()) {
-        log::debug!("[vault] sync_vault: touch_last_synced failed err={err}");
+        log::debug!("[vault] sync: touch_last_synced failed err={err}");
     }
     report.duration_ms = (Utc::now() - started).num_milliseconds();
     log::debug!(
-        "[vault] sync_vault: exit id={} scanned={} ingested={} unchanged={} removed={} failed={} skipped={} duration_ms={}",
+        "[vault] sync: exit id={} scanned={} ingested={} unchanged={} removed={} failed={} skipped={} duration_ms={}",
         vault.id,
         report.scanned,
         report.ingested,
diff --git a/src/openhuman/vault/tests.rs b/src/openhuman/vault/tests.rs
index ad02171b8..ead1c2f1e 100644
--- a/src/openhuman/vault/tests.rs
+++ b/src/openhuman/vault/tests.rs
@@ -6,9 +6,11 @@ use tempfile::TempDir;
 
 use crate::openhuman::config::Config;
 
+use super::ops;
+use super::state;
 use super::store;
 use super::sync::supported_extension;
-use super::types::{Vault, VaultFile, VaultFileStatus};
+use super::types::{Vault, VaultFile, VaultFileStatus, VaultSyncState, VaultSyncStatus};
 
 fn make_config(tmp: &TempDir) -> Config {
     let mut config = Config::default();
@@ -128,3 +130,177 @@ fn remove_vault_cascades_files() {
     // Cascade should have wiped vault_files rows for this id.
     assert!(store::list_files(&config, &vault.id).unwrap().is_empty());
 }
+
+// ---------------------------------------------------------------------------
+// state.rs — in-memory sync state registry
+// ---------------------------------------------------------------------------
+
+fn make_state(vault_id: &str, status: VaultSyncStatus) -> VaultSyncState {
+    VaultSyncState {
+        vault_id: vault_id.to_string(),
+        status,
+        scanned: 0,
+        ingested: 0,
+        unchanged: 0,
+        removed: 0,
+        failed: 0,
+        skipped_unsupported: 0,
+        total: 0,
+        started_at_ms: 100,
+        finished_at_ms: None,
+        duration_ms: 0,
+        errors: vec![],
+    }
+}
+
+#[test]
+fn state_get_returns_none_for_unknown() {
+    // Use a unique ID so parallel tests can't collide via the global map.
+    assert!(state::get("__test_unknown_99z__").is_none());
+}
+
+#[test]
+fn state_set_and_get_roundtrip() {
+    let id = "__test_set_1__";
+    state::set(make_state(id, VaultSyncStatus::Completed));
+    let st = state::get(id).unwrap();
+    assert_eq!(st.status, VaultSyncStatus::Completed);
+    assert_eq!(st.vault_id, id);
+}
+
+#[test]
+fn state_start_creates_running_entry() {
+    let id = "__test_start_1__";
+    state::start(id, 12345).unwrap();
+    let st = state::get(id).unwrap();
+    assert_eq!(st.status, VaultSyncStatus::Running);
+    assert_eq!(st.started_at_ms, 12345);
+    assert_eq!(st.ingested, 0);
+}
+
+#[test]
+fn state_start_rejects_duplicate_running() {
+    let id = "__test_start_dup__";
+    state::start(id, 1).unwrap();
+    let err = state::start(id, 2).unwrap_err();
+    assert!(err.contains("already syncing"));
+}
+
+#[test]
+fn state_start_allowed_after_completed() {
+    let id = "__test_start_after_completed__";
+    state::start(id, 1).unwrap();
+    // Mark as completed, then start again — must succeed.
+    state::update_progress(id, |s| s.status = VaultSyncStatus::Completed);
+    state::start(id, 2).unwrap();
+    assert_eq!(state::get(id).unwrap().status, VaultSyncStatus::Running);
+}
+
+#[test]
+fn state_start_allowed_after_failed() {
+    let id = "__test_start_after_failed__";
+    state::start(id, 1).unwrap();
+    state::update_progress(id, |s| s.status = VaultSyncStatus::Failed);
+    state::start(id, 2).unwrap();
+    assert_eq!(state::get(id).unwrap().status, VaultSyncStatus::Running);
+}
+
+#[test]
+fn state_update_progress_mutates_entry() {
+    let id = "__test_update_1__";
+    state::start(id, 1).unwrap();
+    state::update_progress(id, |s| {
+        s.ingested = 7;
+        s.scanned = 10;
+        s.total = 10;
+    });
+    let st = state::get(id).unwrap();
+    assert_eq!(st.ingested, 7);
+    assert_eq!(st.scanned, 10);
+}
+
+#[test]
+fn state_update_progress_noop_on_missing() {
+    // Must not panic when vault_id is absent from the map.
+    state::update_progress("__test_noop_xyz__", |s| {
+        s.ingested = 999; // should never execute
+    });
+}
+
+// ---------------------------------------------------------------------------
+// ops.rs — vault_sync_status RPC operation
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn vault_sync_status_returns_idle_for_unknown_vault() {
+    let outcome = ops::vault_sync_status("__ops_status_unknown__")
+        .await
+        .unwrap();
+    assert_eq!(outcome.value.status, VaultSyncStatus::Idle);
+    assert_eq!(outcome.value.vault_id, "__ops_status_unknown__");
+    assert_eq!(outcome.value.ingested, 0);
+}
+
+#[tokio::test]
+async fn vault_sync_status_returns_state_when_present() {
+    let id = "__ops_status_running__";
+    let mut st = make_state(id, VaultSyncStatus::Running);
+    st.scanned = 10;
+    st.ingested = 5;
+    st.total = 10;
+    state::set(st);
+
+    let outcome = ops::vault_sync_status(id).await.unwrap();
+    assert_eq!(outcome.value.status, VaultSyncStatus::Running);
+    assert_eq!(outcome.value.scanned, 10);
+    assert_eq!(outcome.value.ingested, 5);
+    assert_eq!(outcome.value.total, 10);
+}
+
+#[tokio::test]
+async fn vault_sync_status_returns_completed_state() {
+    let id = "__ops_status_completed__";
+    let mut st = make_state(id, VaultSyncStatus::Completed);
+    st.ingested = 12;
+    st.failed = 1;
+    st.duration_ms = 500;
+    st.errors = vec!["file.txt: too large".to_string()];
+    state::set(st);
+
+    let outcome = ops::vault_sync_status(id).await.unwrap();
+    assert_eq!(outcome.value.status, VaultSyncStatus::Completed);
+    assert_eq!(outcome.value.ingested, 12);
+    assert_eq!(outcome.value.failed, 1);
+    assert_eq!(outcome.value.errors.len(), 1);
+}
+
+#[tokio::test]
+async fn vault_sync_status_rejects_empty_id() {
+    let err = ops::vault_sync_status("").await.unwrap_err();
+    assert!(err.contains("vault_id must not be empty"));
+}
+
+#[tokio::test]
+async fn vault_sync_panic_guard_marks_state_failed_and_allows_retry() {
+    // Simulate the panic-recovery path that the catch_unwind guard in
+    // ops::vault_sync triggers: vault goes Running -> Failed (with a panic
+    // message), then can be restarted.  This verifies the invariant that no
+    // panic can permanently lock the state in `Running`.
+    let id = "__test_panic_guard_recovery__";
+    state::start(id, 1_000).unwrap();
+    assert_eq!(state::get(id).unwrap().status, VaultSyncStatus::Running);
+
+    // Simulate what the Err(_) branch of the catch_unwind match does.
+    state::update_progress(id, |s| {
+        s.status = VaultSyncStatus::Failed;
+        s.errors = vec!["sync task panicked unexpectedly".to_string()];
+    });
+
+    let st = state::get(id).unwrap();
+    assert_eq!(st.status, VaultSyncStatus::Failed);
+    assert!(st.errors[0].contains("panicked"));
+
+    // A subsequent sync attempt must not be blocked by the old Running entry.
+    state::start(id, 2_000).unwrap();
+    assert_eq!(state::get(id).unwrap().status, VaultSyncStatus::Running);
+}
diff --git a/src/openhuman/vault/types.rs b/src/openhuman/vault/types.rs
index 7afad7c93..c3d204653 100644
--- a/src/openhuman/vault/types.rs
+++ b/src/openhuman/vault/types.rs
@@ -1,6 +1,50 @@
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 
+/// Status of a running or completed vault sync operation.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum VaultSyncStatus {
+    #[default]
+    Idle,
+    Running,
+    Completed,
+    Failed,
+}
+
+/// Live progress for a vault sync operation.
+///
+/// Held in the global registry while a sync is in flight, and retained after
+/// completion so the frontend can poll the final outcome without timing
+/// concerns. The next `vault.sync` call for the same vault overwrites this.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct VaultSyncState {
+    pub vault_id: String,
+    pub status: VaultSyncStatus,
+    /// Files seen by the directory walker (updated after discovery phase).
+    pub scanned: u64,
+    /// Files successfully ingested so far.
+    pub ingested: u64,
+    /// Files skipped because hash+mtime was unchanged.
+    pub unchanged: u64,
+    /// Files removed from the vault (source file gone).
+    pub removed: u64,
+    /// Files that failed ingestion.
+    pub failed: u64,
+    /// Files skipped (unsupported extension or too large).
+    pub skipped_unsupported: u64,
+    /// Total files queued for ingestion (set after discovery; 0 while walking).
+    pub total: u64,
+    /// Unix milliseconds when this sync started.
+    pub started_at_ms: i64,
+    /// Unix milliseconds when this sync finished; `None` while still running.
+    pub finished_at_ms: Option<i64>,
+    /// Wall-clock duration in ms; 0 while running; set from VaultSyncReport on completion.
+    pub duration_ms: i64,
+    /// Accumulated error strings.
+    pub errors: Vec<String>,
+}
+
 /// A user-registered local folder whose files are mirrored into memory.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct Vault {