feat(session-management): optimize provider merge with snapshot-based updates

Pass the frontend-side snapshot to UpdateCodexSessionProviders so the
backend can update provider mappings in-place without a cold full-scan.
The runtime bridge now takes priority over dev HTTP bridge on desktop.
Also adds a loading spinner to the save button for better UX.

Author: linhay

frontend/src/features/session-management/SessionManagementFeature.tsx

@@ -92,6 +92,7 @@ export default function SessionManagementFeature({ workspace = 'codex' }: Sessio
     updateDraftValue,
     saveProviderMerge,
   } = useSessionManagementProviderMerge({
+    snapshot,
     projects,
     unknownProviderLabel: copy.unknownProvider,
     loadFailedMessage: copy.loadFailed,

frontend/src/features/session-management/SessionManagementView.tsx

@@ -686,7 +686,7 @@ export function ProviderMergeModal({
             return (
               <div key={row.sourceKey} className="flex items-center gap-3 px-5 py-4">
                 <div className="min-w-0 flex-1">
-                  <div className="truncate text-[0.8125rem] font-black uppercase tracking-tight">
+                  <div className="truncate text-[0.8125rem] font-black normal-case tracking-tight">
                     {sourceLabel}
                   </div>
                   <div className="mt-0.5 text-[0.5rem] font-black uppercase tracking-[0.18em] text-[var(--text-muted)]">
@@ -743,9 +743,11 @@ export function ProviderMergeModal({
               type="button"
               onClick={onSave}
               disabled={saving}
-              className="btn-swiss text-[0.5625rem] disabled:opacity-50"
+              aria-busy={saving}
+              className="btn-swiss inline-flex items-center gap-1.5 text-[0.5625rem] disabled:opacity-50"
             >
-              {saving ? '保存中…' : '保存'}
+              {saving ? <RefreshCw className="h-3 w-3 animate-spin" strokeWidth={2.5} aria-hidden="true" /> : null}
+              <span>{saving ? '保存中…' : '保存'}</span>
             </button>
           </div>
         </div>

frontend/src/features/session-management/api.ts

@@ -14,7 +14,45 @@ interface SessionManagementRuntimeApp {
   GetCodexSessionManagementSnapshot?: () => Promise<unknown>;
   RefreshCodexSessionManagementSnapshot?: () => Promise<unknown>;
   GetCodexSessionDetail?: (sessionID: string) => Promise<unknown>;
-  UpdateCodexSessionProviders?: (input: { projectID: string; mappings: Array<{ sourceProvider: string; targetProvider: string }> }) => Promise<unknown>;
+  UpdateCodexSessionProviders?: (input: {
+    projectID: string;
+    mappings: Array<{ sourceProvider: string; targetProvider: string }>;
+    snapshot?: RuntimeSessionManagementSnapshot;
+  }) => Promise<unknown>;
+}
+
+interface RuntimeSessionManagementSnapshot {
+  projectCount: number;
+  sessionCount: number;
+  activeSessionCount: number;
+  archivedSessionCount: number;
+  lastScanAt: string;
+  providerCounts: Record<string, number>;
+  projects: Array<{
+    id: string;
+    name: string;
+    providerCounts: Record<string, number>;
+    sessionCount: number;
+    activeSessionCount: number;
+    archivedSessionCount: number;
+    lastActiveAt: string;
+    providerSummary: string;
+    sessions: Array<{
+      id: string;
+      sessionID: string;
+      projectID: string;
+      projectName: string;
+      title: string;
+      status: string;
+      archived: boolean;
+      messageCount: number;
+      roleSummary: string;
+      updatedAt: string;
+      fileLabel: string;
+      summary: string;
+      provider: string;
+    }>;
+  }>;
 }
 
 declare global {
@@ -28,11 +66,21 @@ declare global {
 }
 
 function resolveRuntimeMethod<T extends keyof SessionManagementRuntimeApp>(methodName: T) {
+  const method = getRuntimeMethod(methodName);
+
+  if (!method) {
+    throw new Error(`当前运行时缺少 ${methodName} 绑定。`);
+  }
+
+  return method;
+}
+
+function getRuntimeMethod<T extends keyof SessionManagementRuntimeApp>(methodName: T) {
   const app = globalThis.window?.go?.main?.App;
   const method = app?.[methodName];
 
   if (typeof method !== 'function') {
-    throw new Error(`当前运行时缺少 ${methodName} 绑定。`);
+    return null;
   }
 
   return method.bind(app) as NonNullable<SessionManagementRuntimeApp[T]>;
@@ -141,57 +189,141 @@ async function updateDevProviders(projectID: string, mappings: Array<{ sourcePro
   throw lastError ?? new Error('session management provider merge unavailable');
 }
 
+function addProviderCount(counts: Record<string, number>, provider: string) {
+  const key = provider.trim();
+  if (!key || key === '—') {
+    return;
+  }
+  counts[key] = (counts[key] ?? 0) + 1;
+}
+
+function toRuntimeSessionManagementSnapshot(
+  snapshot?: SessionManagementSnapshot,
+): RuntimeSessionManagementSnapshot | undefined {
+  if (!snapshot) {
+    return undefined;
+  }
+
+  const providerCounts: Record<string, number> = {};
+  const projects = snapshot.projects.map((project) => {
+    const projectProviderCounts: Record<string, number> = {};
+    const sessions = project.sessions.map((session) => {
+      addProviderCount(providerCounts, session.provider);
+      addProviderCount(projectProviderCounts, session.provider);
+      return {
+        id: session.id,
+        sessionID: session.id,
+        projectID: project.id,
+        projectName: project.name,
+        title: session.title,
+        status: session.status,
+        archived: session.status === 'archived',
+        messageCount: session.messageCount,
+        roleSummary: session.roleSummary,
+        updatedAt: session.updatedAt,
+        fileLabel: session.fileLabel,
+        summary: session.summary,
+        provider: session.provider,
+      };
+    });
+
+    return {
+      id: project.id,
+      name: project.name,
+      providerCounts: projectProviderCounts,
+      sessionCount: project.sessionCount,
+      activeSessionCount: project.activeSessionCount,
+      archivedSessionCount: project.archivedSessionCount,
+      lastActiveAt: project.lastActiveAt,
+      providerSummary: project.providerSummary,
+      sessions,
+    };
+  });
+
+  return {
+    projectCount: snapshot.stats.projectCount,
+    sessionCount: snapshot.stats.sessionCount,
+    activeSessionCount: snapshot.stats.activeSessionCount,
+    archivedSessionCount: snapshot.stats.archivedSessionCount,
+    lastScanAt: snapshot.stats.lastScanAt,
+    providerCounts,
+    projects,
+  };
+}
+
 export async function getCodexSessionManagementSnapshot(): Promise<SessionManagementSnapshot> {
   if (hasSessionManagementPreviewMode()) {
     return getSessionManagementPreviewSnapshot();
   }
+  const getSnapshot = getRuntimeMethod('GetCodexSessionManagementSnapshot');
+  if (getSnapshot) {
+    const raw = await getSnapshot();
+    return mapSessionManagementSnapshotResponse(raw);
+  }
   if (canUseSessionManagementDevHTTP()) {
     return mapSessionManagementSnapshotResponse(await loadDevSnapshot(false));
   }
 
-  const getSnapshot = resolveRuntimeMethod('GetCodexSessionManagementSnapshot');
-  const raw = await getSnapshot();
+  const missingSnapshot = resolveRuntimeMethod('GetCodexSessionManagementSnapshot');
+  const raw = await missingSnapshot();
   return mapSessionManagementSnapshotResponse(raw);
 }
 
 export async function refreshCodexSessionManagementSnapshot(): Promise<SessionManagementSnapshot> {
   if (hasSessionManagementPreviewMode()) {
     return getSessionManagementPreviewSnapshot();
   }
+  const refreshSnapshot = getRuntimeMethod('RefreshCodexSessionManagementSnapshot');
+  if (refreshSnapshot) {
+    const raw = await refreshSnapshot();
+    return mapSessionManagementSnapshotResponse(raw);
+  }
   if (canUseSessionManagementDevHTTP()) {
     return mapSessionManagementSnapshotResponse(await loadDevSnapshot(true));
   }
 
-  const refreshSnapshot = resolveRuntimeMethod('RefreshCodexSessionManagementSnapshot');
-  const raw = await refreshSnapshot();
+  const missingRefreshSnapshot = resolveRuntimeMethod('RefreshCodexSessionManagementSnapshot');
+  const raw = await missingRefreshSnapshot();
   return mapSessionManagementSnapshotResponse(raw);
 }
 
 export async function getCodexSessionDetail(sessionID: string): Promise<SessionDetail> {
   if (hasSessionManagementPreviewMode()) {
     return getSessionManagementPreviewDetail(sessionID);
   }
+  const getDetail = getRuntimeMethod('GetCodexSessionDetail');
+  if (getDetail) {
+    const raw = await getDetail(sessionID);
+    return mapSessionDetailResponse(raw);
+  }
   if (canUseSessionManagementDevHTTP()) {
     return mapSessionDetailResponse(await loadDevDetail(sessionID));
   }
 
-  const getDetail = resolveRuntimeMethod('GetCodexSessionDetail');
-  const raw = await getDetail(sessionID);
+  const missingDetail = resolveRuntimeMethod('GetCodexSessionDetail');
+  const raw = await missingDetail(sessionID);
   return mapSessionDetailResponse(raw);
 }
 
 export async function updateCodexSessionProviders(
   projectID: string,
   mappings: Array<{ sourceProvider: string; targetProvider: string }>,
+  snapshot?: SessionManagementSnapshot,
 ): Promise<SessionManagementSnapshot> {
   if (hasSessionManagementPreviewMode()) {
     throw new Error('preview 模式不支持修改 provider');
   }
+  const updateProviders = getRuntimeMethod('UpdateCodexSessionProviders');
+  const runtimeSnapshot = toRuntimeSessionManagementSnapshot(snapshot);
+  if (updateProviders) {
+    const raw = await updateProviders({ projectID, mappings, snapshot: runtimeSnapshot });
+    return mapSessionManagementSnapshotResponse(raw);
+  }
   if (canUseSessionManagementDevHTTP()) {
     return mapSessionManagementSnapshotResponse(await updateDevProviders(projectID, mappings));
   }
 
-  const updateProviders = resolveRuntimeMethod('UpdateCodexSessionProviders');
-  const raw = await updateProviders({ projectID, mappings });
+  const missingUpdateProviders = resolveRuntimeMethod('UpdateCodexSessionProviders');
+  const raw = await missingUpdateProviders({ projectID, mappings, snapshot: runtimeSnapshot });
   return mapSessionManagementSnapshotResponse(raw);
 }