@finos/legend-application-studio 28.21.5 → 28.21.7

package/src/components/workspace-setup/WorkspaceSetup.tsx

@@ -52,6 +52,7 @@ import { CreateProjectModal } from './CreateProjectModal.js';
 import { ActivityBarMenu } from '../editor/ActivityBar.js';
 import { LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY } from '../../__lib__/LegendStudioApplicationNavigationContext.js';
 import { CreateWorkspaceModal } from './CreateWorkspaceModal.js';
+import { RecentWorkspacesPanel } from './RecentWorkspacesPanel.js';
 import {
   useLegendStudioApplicationStore,
   useLegendStudioBaseStore,
@@ -66,7 +67,12 @@ import {
   buildWorkspaceOption,
   formatWorkspaceOptionLabel,
 } from './WorkspaceSelectorUtils.js';
-import { debounce, guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  debounce,
+  guaranteeNonNullable,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { Project } from '@finos/legend-server-sdlc';
 import { WorkspaceSetupStore } from '../../stores/workspace-setup/WorkspaceSetupStore.js';
 import { openShowcaseManager } from '../../stores/ShowcaseManagerState.js';
 
@@ -360,18 +366,56 @@ export const WorkspaceSetup = withWorkspaceSetupStore(
       applicationStore.assistantService.toggleAssistant();
 
     // projects
-    const projectOptions = setupStore.projects
+    // Build a unified option list: recent projects (that aren't already in the
+    // loaded set) are prepended so users can instantly re-open common work
+    // without waiting for the SDLC search to round-trip.
+    const loadedProjectOptions = setupStore.projects
       .map(buildProjectOption)
       .sort(compareLabelFn);
+    const loadedProjectIds = new Set(
+      setupStore.projects.map((p) => p.projectId),
+    );
+    const recentProjectOptions: ProjectOption[] = setupStore.recentProjects
+      .filter((r) => !loadedProjectIds.has(r.projectId))
+      .map((r) => {
+        // Rebuild a real Project from the cached metadata; no synthetic
+        // fields needed since we persist everything the schema requires.
+        const stub = Project.serialization.fromJson({
+          projectId: r.projectId,
+          name: r.name,
+          description: r.description,
+          webUrl: r.webUrl,
+          tags: r.tags,
+        } as PlainObject<Project>);
+        return { label: stub.name, value: stub };
+      });
+    const projectOptions: ProjectOption[] = [
+      ...recentProjectOptions,
+      ...loadedProjectOptions,
+    ];
+    const recentProjectIdSet = new Set(
+      setupStore.recentProjects.map((p) => p.projectId),
+    );
     const selectedProjectOption = setupStore.currentProject
       ? buildProjectOption(setupStore.currentProject)
       : null;
 
     const onProjectChange = (val: ProjectOption | null): void => {
       if (val) {
-        flowResult(setupStore.changeProject(val.value)).catch(
-          applicationStore.alertUnhandledError,
-        );
+        // If the selection corresponds to a recent that hasn't been loaded
+        // from search yet, fetch the project before switching.
+        const isUnloadedRecent =
+          !loadedProjectIds.has(val.value.projectId) &&
+          recentProjectIdSet.has(val.value.projectId);
+        if (isUnloadedRecent) {
+          flowResult(setupStore.selectRecentProject(val.value.projectId)).catch(
+            applicationStore.alertUnhandledError,
+          );
+        } else {
+          flowResult(setupStore.changeProject(val.value)).catch(
+            applicationStore.alertUnhandledError,
+          );
+        }
       } else {
         setupStore.resetProject();
       }
@@ -404,9 +448,40 @@ export const WorkspaceSetup = withWorkspaceSetupStore(
     };
 
     // workspaces
-    const workspaceOptions = setupStore.workspaces
-      .map(buildWorkspaceOption)
+    // Recent (non-patch) workspaces for the currently selected project are
+    // floated to the top of the dropdown so users can re-enter their
+    // typical work without scanning the full list.
+    const projectIdForRecents = setupStore.currentProject?.projectId;
+    const recentWorkspaceKeys = new Set(
+      projectIdForRecents
+        ? setupStore.recentWorkspaces
+            .filter((w) => w.projectId === projectIdForRecents)
+            .map((w) => `${w.workspaceType}::${w.workspaceId}`)
+        : [],
+    );
+    const allWorkspaceOptions = setupStore.workspaces.map(buildWorkspaceOption);
+    const recentWorkspaceOptions = allWorkspaceOptions
+      .filter(
+        (o) =>
+          o.value.source === undefined &&
+          recentWorkspaceKeys.has(
+            `${o.value.workspaceType}::${o.value.workspaceId}`,
+          ),
+      )
+      .sort(compareLabelFn);
+    const otherWorkspaceOptions = allWorkspaceOptions
+      .filter(
+        (o) =>
+          o.value.source !== undefined ||
+          !recentWorkspaceKeys.has(
+            `${o.value.workspaceType}::${o.value.workspaceId}`,
+          ),
+      )
       .sort(compareLabelFn);
+    const workspaceOptions = [
+      ...recentWorkspaceOptions,
+      ...otherWorkspaceOptions,
+    ];
     const selectedWorkspaceOption = setupStore.currentWorkspace
       ? buildWorkspaceOption(setupStore.currentWorkspace)
       : null;
@@ -489,11 +564,24 @@ export const WorkspaceSetup = withWorkspaceSetupStore(
                       Welcome to Legend Studio
                     </div>
                   </div>
+                  <RecentWorkspacesPanel setupStore={setupStore} />
                   <div className="workspace-setup__selectors">
                     <div className="workspace-setup__selectors__container">
                       <div className="workspace-setup__selector">
                         <div className="workspace-setup__selector__header">
-                          Search for an existing project
+                          <span>Search for an existing project</span>
+                          {(setupStore.recentProjects.length > 0 ||
+                            setupStore.recentWorkspaces.length > 0) && (
+                            <button
+                              type="button"
+                              className="workspace-setup__selector__header__clear-recents"
+                              tabIndex={-1}
+                              onClick={() => setupStore.clearRecents()}
+                              title="Clear recently-opened projects and workspaces"
+                            >
+                              Clear recents
+                            </button>
+                          )}
                         </div>
                         <div className="workspace-setup__selector__content">
                           <div

package/src/stores/editor/EditorStore.ts

@@ -93,6 +93,7 @@ import {
   DEFAULT_TAB_SIZE,
 } from '@finos/legend-application';
 import { LEGEND_STUDIO_APP_EVENT } from '../../__lib__/LegendStudioEvent.js';
+import { LegendStudioUserDataHelper } from '../../__lib__/LegendStudioUserDataHelper.js';
 import type { EditorMode } from './EditorMode.js';
 import { StandardEditorMode } from './StandardEditorMode.js';
 import { WorkspaceUpdateConflictResolutionState } from './sidebar-state/WorkspaceUpdateConflictResolutionState.js';
@@ -691,6 +692,12 @@ export class EditorStore implements CommandRegistrar {
       }),
     );
     if (!this.sdlcState.currentProject) {
+      // The project the user navigated to doesn't exist (or isn't accessible).
+      // Drop it from the recents cache so we don't keep offering a dead link.
+      LegendStudioUserDataHelper.workspaceSetup_removeRecentProject(
+        this.applicationStore.userDataService,
+        projectId,
+      );
       // If the project is not found or the user does not have access to it,
       // we will not automatically redirect them to the setup page as they will lose the URL
       // instead, we give them the option to:
@@ -740,6 +747,15 @@ export class EditorStore implements CommandRegistrar {
       ),
     );
     if (!this.sdlcState.currentWorkspace) {
+      // The workspace the user navigated to doesn't exist anymore. Drop
+      // the matching entry from the recents cache (no-op for patch
+      // workspaces, which are never cached in the first place).
+      if (patchReleaseVersionId === undefined) {
+        LegendStudioUserDataHelper.workspaceSetup_removeRecentWorkspace(
+          this.applicationStore.userDataService,
+          { projectId, workspaceId, workspaceType },
+        );
+      }
       // If the workspace is not found,
       // we will not automatically redirect the user to the setup page as they will lose the URL
       // instead, we give them the option to:
@@ -810,6 +826,37 @@ export class EditorStore implements CommandRegistrar {
       onLeave(false);
       return;
     }
+    // At this point both the project and the workspace have been confirmed
+    // to exist on the server (the guards above bail out otherwise), so this
+    // is the authoritative "the user actually opened this workspace" moment.
+    // Record it in the recents cache so the workspace setup screen can offer
+    // it instantly next time.
+    // NOTE: patch-based workspaces are intentionally excluded from recents
+    // (they are not surfaced in the recents UI). Sandbox projects ARE
+    // included — opening one is still a meaningful "I worked here" signal,
+    // and surfacing it alongside other recents gives a faster one-click
+    // re-entry than waiting for the dedicated sandbox loader.
+    if (this.sdlcState.currentWorkspace.source === undefined) {
+      LegendStudioUserDataHelper.workspaceSetup_recordRecentProject(
+        this.applicationStore.userDataService,
+        {
+          projectId: this.sdlcState.currentProject.projectId,
+          name: this.sdlcState.currentProject.name,
+          description: this.sdlcState.currentProject.description,
+          webUrl: this.sdlcState.currentProject.webUrl,
+          tags: this.sdlcState.currentProject.tags,
+        },
+      );
+      LegendStudioUserDataHelper.workspaceSetup_recordRecentWorkspace(
+        this.applicationStore.userDataService,
+        {
+          projectId: this.sdlcState.currentProject.projectId,
+          workspaceId: this.sdlcState.currentWorkspace.workspaceId,
+          workspaceType: this.sdlcState.currentWorkspace.workspaceType,
+        },
+      );
+    }
+
     yield Promise.all([
       this.sdlcState.fetchCurrentRevision(
         projectId,

package/src/stores/editor/editor-state/element-editor-state/function-activator/testable/FunctionTestableState.ts

@@ -63,7 +63,9 @@ import {
   EqualTo,
   EqualToRelation,
   RelationElement,
+  RelationRowTestData,
   observe_RelationElement,
+  observe_RelationRowTestData,
   ModelStore,
   RelationElementsData,
   CORE_PURE_PATH,
@@ -723,7 +725,6 @@ export const createFunctionTest = async (
     assertion.id = DEFAULT_TEST_ASSERTION_ID;
     const expectedRelElement = new RelationElement();
     expectedRelElement.paths = [];
-    expectedRelElement.rows = [];
     let inferredColumns: string[] = [];
     if (type.path === CORE_PURE_PATH.RELATION) {
       try {
@@ -746,6 +747,9 @@ export const createFunctionTest = async (
       }
     }
     expectedRelElement.columns = inferredColumns;
+    const emptyRow = observe_RelationRowTestData(new RelationRowTestData());
+    emptyRow.values = inferredColumns.map(() => '');
+    expectedRelElement.rows = [emptyRow];
     observe_RelationElement(expectedRelElement);
     assertion.expected = expectedRelElement;
     _assertion = assertion;

package/src/stores/editor/sidebar-state/ProjectOverviewState.ts

@@ -42,6 +42,7 @@ import {
   type WorkspaceType,
 } from '@finos/legend-server-sdlc';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
+import { LegendStudioUserDataHelper } from '../../../__lib__/LegendStudioUserDataHelper.js';
 
 export enum PROJECT_OVERVIEW_ACTIVITY_MODE {
   RELEASE = 'RELEASE',
@@ -155,6 +156,19 @@ export class ProjectOverviewState {
       this.projectWorkspaces = this.projectWorkspaces.filter(
         (w) => !areWorkspacesEquivalent(workspace, w),
       );
+      // Drop the deleted workspace from the recents cache so the workspace
+      // setup screen doesn't keep offering a dead link. Patch workspaces are
+      // never cached, so this is a no-op for them.
+      if (workspace.source === undefined) {
+        LegendStudioUserDataHelper.workspaceSetup_removeRecentWorkspace(
+          this.editorStore.applicationStore.userDataService,
+          {
+            projectId: this.sdlcState.activeProject.projectId,
+            workspaceId: workspace.workspaceId,
+            workspaceType: workspace.workspaceType,
+          },
+        );
+      }
       // redirect to home page if current workspace is deleted
       if (
         areWorkspacesEquivalent(

package/src/stores/editor/sidebar-state/WorkspaceReviewState.ts

@@ -25,6 +25,7 @@ import {
 import type { EditorStore } from '../EditorStore.js';
 import type { EditorSDLCState } from '../EditorSDLCState.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
+import { LegendStudioUserDataHelper } from '../../../__lib__/LegendStudioUserDataHelper.js';
 import {
   type GeneratorFn,
   type PlainObject,
@@ -402,6 +403,19 @@ export class WorkspaceReviewState {
         review.id,
         { message: `${review.title} [review]` },
       );
+      // Committing a review deletes the workspace on SDLC. Drop it from
+      // the recents cache so the workspace setup screen doesn't keep
+      // offering a dead link. Patch workspaces are never cached.
+      if (this.sdlcState.activePatch === undefined) {
+        LegendStudioUserDataHelper.workspaceSetup_removeRecentWorkspace(
+          this.editorStore.applicationStore.userDataService,
+          {
+            projectId: this.sdlcState.activeProject.projectId,
+            workspaceId: this.sdlcState.activeWorkspace.workspaceId,
+            workspaceType: this.sdlcState.activeWorkspace.workspaceType,
+          },
+        );
+      }
       this.editorStore.applicationStore.alertService.setActionAlertInfo({
         message: 'Committed review successfully',
         prompt:

package/src/stores/editor/sidebar-state/dev-metadata/DevMetadataState.ts

@@ -156,6 +156,13 @@ export class DevMetadataState {
         'Project Name required to push to dev mode',
       );
       this.pushState.inProgress();
+      LegendStudioTelemetryHelper.logEvent_DevMetadataPushLaunched(
+        this.editorStore.applicationStore.telemetryService,
+        this.editorStore.editorMode.getSourceInfo(),
+        currentProjectConfiguration.groupId,
+        currentProjectConfiguration.artifactId,
+        undefined,
+      );
       const result =
         (yield this.editorStore.graphManagerState.graphManager.pushToDevMetadata(
           currentProjectConfiguration.groupId,
@@ -165,7 +172,7 @@ export class DevMetadataState {
           this.editorStore.graphManagerState.graph,
         )) as DeployProjectResponse;
       this.result = result;
-      LegendStudioTelemetryHelper.logEvent_DevMetadataPushLaunched(
+      LegendStudioTelemetryHelper.logEvent_DevMetadataPushSucceeded(
         this.editorStore.applicationStore.telemetryService,
         this.editorStore.editorMode.getSourceInfo(),
         currentProjectConfiguration.groupId,

package/src/stores/project-reviewer/ProjectReviewerStore.ts

@@ -45,6 +45,7 @@ import {
   ReviewApproval,
 } from '@finos/legend-server-sdlc';
 import { LEGEND_STUDIO_APP_EVENT } from '../../__lib__/LegendStudioEvent.js';
+import { LegendStudioUserDataHelper } from '../../__lib__/LegendStudioUserDataHelper.js';
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
 import type { Entity } from '@finos/legend-storage';
 import { EntityDiffViewState } from '../editor/editor-state/entity-diff-editor-state/EntityDiffViewState.js';
@@ -457,6 +458,20 @@ export class ProjectReviewerStore {
           { message: `${this.review.title} [review]` },
         )) as PlainObject<Review>,
       );
+      // Committing a review deletes its workspace on SDLC. Drop the
+      // matching entry from the local recents cache (no-op if it wasn't
+      // there, e.g., the reviewer isn't the workspace author). Patch
+      // workspaces are never cached.
+      if (this.patchReleaseVersionId === undefined) {
+        LegendStudioUserDataHelper.workspaceSetup_removeRecentWorkspace(
+          this.editorStore.applicationStore.userDataService,
+          {
+            projectId: this.projectId,
+            workspaceId: this.review.workspaceId,
+            workspaceType: this.review.workspaceType,
+          },
+        );
+      }
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(

package/src/stores/workspace-setup/WorkspaceSetupStore.ts

@@ -51,6 +51,11 @@ import {
   ProjectConfigurationStatus,
 } from './ProjectConfigurationStatus.js';
 import { GraphManagerState } from '@finos/legend-graph';
+import {
+  LegendStudioUserDataHelper,
+  type RecentProjectEntry,
+  type RecentWorkspaceEntry,
+} from '../../__lib__/LegendStudioUserDataHelper.js';
 
 interface ImportProjectSuccessReport {
   projectId: string;
@@ -88,10 +93,15 @@ export class WorkspaceSetupStore {
   loadWorkspacesState = ActionState.create();
   createWorkspaceState = ActionState.create();
   showCreateWorkspaceModal = false;
-  showAdvancedWorkspaceFilterOptions = false;
 
   graphManagerState: GraphManagerState;
 
+  // Cached recents to make re-opening a project/workspace instantaneous.
+  // NOTE: patch-based workspaces are intentionally excluded from this cache.
+  recentProjects: RecentProjectEntry[] = [];
+  recentWorkspaces: RecentWorkspaceEntry[] = [];
+  selectRecentProjectState = ActionState.create();
+
   constructor(
     applicationStore: LegendStudioApplicationStore,
     sdlcServerClient: SDLCServerClient,
@@ -104,7 +114,6 @@ export class WorkspaceSetupStore {
       showCreateProjectModal: observable,
       workspaces: observable,
       currentWorkspace: observable,
-      showAdvancedWorkspaceFilterOptions: observable,
       loadSandboxState: observable,
       showCreateWorkspaceModal: observable,
       sandboxProject: observable,
@@ -113,14 +122,18 @@ export class WorkspaceSetupStore {
       enginePromise: observable,
       sandboxModal: observable,
       hasSandboxAccess: observable,
+      recentProjects: observable,
+      recentWorkspaces: observable,
       setShowCreateProjectModal: action,
       setShowCreateWorkspaceModal: action,
-      setShowAdvancedWorkspaceFilterOptions: action,
       setImportProjectSuccessReport: action,
       setSandboxModal: action,
       changeWorkspace: action,
       resetProject: action,
       resetWorkspace: action,
+      removeRecentProject: action,
+      removeRecentWorkspace: action,
+      clearRecents: action,
       initialize: flow,
       loadProjects: flow,
       loadSandboxProject: flow,
@@ -130,6 +143,7 @@ export class WorkspaceSetupStore {
       createSandboxProject: flow,
       createWorkspace: flow,
       initializeEngine: flow,
+      selectRecentProject: flow,
     });
 
     this.applicationStore = applicationStore;
@@ -138,6 +152,14 @@ export class WorkspaceSetupStore {
       applicationStore.pluginManager,
       applicationStore.logService,
     );
+    this.recentProjects =
+      LegendStudioUserDataHelper.workspaceSetup_getRecentProjects(
+        applicationStore.userDataService,
+      );
+    this.recentWorkspaces =
+      LegendStudioUserDataHelper.workspaceSetup_getRecentWorkspaces(
+        applicationStore.userDataService,
+      );
     if (this.supportsCreatingSandboxProject) {
       flowResult(this.initializeEngine()).catch(
         applicationStore.alertUnhandledError,
@@ -158,10 +180,6 @@ export class WorkspaceSetupStore {
     this.showCreateWorkspaceModal = val;
   }
 
-  setShowAdvancedWorkspaceFilterOptions(val: boolean): void {
-    this.showAdvancedWorkspaceFilterOptions = val;
-  }
-
   setImportProjectSuccessReport(
     importProjectSuccessReport: ImportProjectSuccessReport | undefined,
   ): void {
@@ -197,6 +215,73 @@ export class WorkspaceSetupStore {
     this.sandboxModal = val;
   }
 
+  // --- Recents -------------------------------------------------------------
+  // NOTE: writes to the recents cache happen from the editor (see
+  // `EditorStore.initialize`) at the moment a workspace is actually opened.
+  // This store only reads the cache (to seed dropdowns) and prunes entries
+  // that are discovered to be stale.
+
+  removeRecentProject(projectId: string): void {
+    const updated =
+      LegendStudioUserDataHelper.workspaceSetup_removeRecentProject(
+        this.applicationStore.userDataService,
+        projectId,
+      );
+    this.recentProjects = updated.projects;
+    this.recentWorkspaces = updated.workspaces;
+  }
+
+  removeRecentWorkspace(entry: {
+    projectId: string;
+    workspaceId: string;
+    workspaceType: WorkspaceType;
+  }): void {
+    this.recentWorkspaces =
+      LegendStudioUserDataHelper.workspaceSetup_removeRecentWorkspace(
+        this.applicationStore.userDataService,
+        entry,
+      );
+  }
+
+  clearRecents(): void {
+    LegendStudioUserDataHelper.workspaceSetup_clearRecents(
+      this.applicationStore.userDataService,
+    );
+    this.recentProjects = [];
+    this.recentWorkspaces = [];
+  }
+
+  /**
+   * Fetches a project by id (used when the user picks a cached "recent"
+   * project that may not be in the current search results) and switches to
+   * it. If the project no longer exists, the entry is pruned from recents.
+   *
+   * NOTE: we deliberately don't short-circuit using the cached recent entry
+   * here. Going through `getProject` keeps the prune-on-404 path intact, and
+   * the cached metadata is already used elsewhere to make the UI feel fast
+   * (dropdown stubs in `WorkspaceSetup.tsx` and tile labels in
+   * `RecentWorkspacesPanel.tsx`).
+   */
+  *selectRecentProject(projectId: string): GeneratorFn<void> {
+    this.selectRecentProjectState.inProgress();
+    try {
+      const project = Project.serialization.fromJson(
+        (yield this.sdlcServerClient.getProject(
+          projectId,
+        )) as PlainObject<Project>,
+      );
+      yield flowResult(this.changeProject(project));
+      this.selectRecentProjectState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.removeRecentProject(projectId);
+      this.applicationStore.notificationService.notifyWarning(
+        `Recent project could not be opened and was removed from recents`,
+      );
+      this.selectRecentProjectState.fail();
+    }
+  }
+
   *createSandboxProject(): GeneratorFn<void> {
     try {
       if (!this.hasSandboxAccess) {
@@ -218,6 +303,12 @@ export class WorkspaceSetupStore {
         message: `Sandbox project ${sandboxProject.projectId} created. Creating default workspace...`,
         showLoading: true,
       });
+      // Invalidate the cached sandbox info so loadSandboxProject re-fetches
+      // and persists the newly-created project id instead of reusing the
+      // stale "no sandbox yet" cache entry.
+      LegendStudioUserDataHelper.workspaceSetup_clearSandboxInfo(
+        this.applicationStore.userDataService,
+      );
       yield flowResult(this.loadSandboxProject());
       const sandbox = guaranteeType(
         this.sandboxProject,
@@ -277,6 +368,7 @@ export class WorkspaceSetupStore {
             )) as PlainObject<Project>,
           );
         } catch {
+          this.removeRecentProject(projectId);
           this.applicationStore.navigationService.navigator.updateCurrentLocation(
             generateSetupRoute(undefined, undefined),
           );
@@ -373,10 +465,58 @@ export class WorkspaceSetupStore {
       if (this.enginePromise) {
         yield this.enginePromise;
       }
+
+      const userId = this.sdlcServerClient.currentUser?.userId;
+
+      // Fast path — if we have a recent, user-matching cache entry, use it to
+      // avoid the `userHasPrototypeProjectAccess` graph manager call and the
+      // sandbox-tag project search. We still hit SDLC once to confirm the
+      // cached projectId is alive, but `getProject(id)` is cheaper than the
+      // tagged search and self-invalidates on 404.
+      if (userId) {
+        const cached =
+          LegendStudioUserDataHelper.workspaceSetup_getCachedSandboxInfo(
+            this.applicationStore.userDataService,
+            userId,
+          );
+        if (cached) {
+          this.hasSandboxAccess = cached.hasAccess;
+          if (!cached.hasAccess) {
+            // No access, no project — nothing else to do.
+            this.sandboxProject = true;
+            this.loadSandboxState.pass();
+            return;
+          }
+          if (cached.projectId) {
+            try {
+              this.sandboxProject = Project.serialization.fromJson(
+                (yield this.sdlcServerClient.getProject(
+                  cached.projectId,
+                )) as PlainObject<Project>,
+              );
+              this.loadSandboxState.pass();
+              return;
+            } catch {
+              // Cached sandbox project no longer exists on the server; drop
+              // the cache and fall through to the full refresh.
+              LegendStudioUserDataHelper.workspaceSetup_clearSandboxInfo(
+                this.applicationStore.userDataService,
+              );
+            }
+          } else {
+            // User has access but hasn't created a sandbox yet.
+            this.sandboxProject = true;
+            this.loadSandboxState.pass();
+            return;
+          }
+        }
+      }
+
+      // Slow path — original flow.
       const sandboxProject = (
         (yield this.sdlcServerClient.getProjects(
           undefined,
-          this.sdlcServerClient.currentUser?.userId,
+          userId,
           [SANDBOX_SDLC_TAG],
           1,
         )) as PlainObject<Project>[]
@@ -384,7 +524,7 @@ export class WorkspaceSetupStore {
       if (this.hasSandboxAccess === undefined) {
         this.hasSandboxAccess =
           (yield this.graphManagerState.graphManager.userHasPrototypeProjectAccess(
-            this.sdlcServerClient.currentUser?.userId ?? '',
+            userId ?? '',
           )) as boolean;
       }
       this.sandboxProject = true;
@@ -395,6 +535,23 @@ export class WorkspaceSetupStore {
       } else if (sandboxProject.length === 1) {
         this.sandboxProject = guaranteeNonNullable(sandboxProject[0]);
       }
+
+      // Persist the fresh result for next time. We only cache when we have
+      // a userId (cache is scoped per user); anonymous sessions skip this.
+      if (userId) {
+        LegendStudioUserDataHelper.workspaceSetup_recordSandboxInfo(
+          this.applicationStore.userDataService,
+          {
+            userId,
+            hasAccess: this.hasSandboxAccess,
+            projectId:
+              this.sandboxProject instanceof Project
+                ? this.sandboxProject.projectId
+                : undefined,
+          },
+        );
+      }
+
       this.loadSandboxState.pass();
     } catch (error) {
       this.sandboxProject = true;
@@ -513,6 +670,12 @@ export class WorkspaceSetupStore {
         if (matchingWorkspace) {
           this.changeWorkspace(matchingWorkspace);
         } else {
+          // Workspace no longer exists — prune from recents.
+          this.removeRecentWorkspace({
+            projectId: project.projectId,
+            workspaceId: workspaceInfo.workspaceId,
+            workspaceType: workspaceInfo.workspaceType,
+          });
           this.applicationStore.navigationService.navigator.updateCurrentLocation(
             generateSetupRoute(project.projectId, undefined),
           );

package/tsconfig.json

@@ -374,6 +374,7 @@
     "./src/components/workspace-setup/CreateProjectModal.tsx",
     "./src/components/workspace-setup/CreateWorkspaceModal.tsx",
     "./src/components/workspace-setup/ProjectSelectorUtils.tsx",
+    "./src/components/workspace-setup/RecentWorkspacesPanel.tsx",
     "./src/components/workspace-setup/WorkspaceSelectorUtils.tsx",
     "./src/components/workspace-setup/WorkspaceSetup.tsx"
   ],