Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
fix(web): restore manual sort drag and keep per-group expand state (#2221)
Mike Olsonde05b0c94e25
diff --git a/apps/web/src/components/Sidebar.logic.test.ts b/apps/web/src/components/Sidebar.logic.test.tsindex 6aa042a16..f92f2f628 100644--- a/apps/web/src/components/Sidebar.logic.test.ts+++ b/apps/web/src/components/Sidebar.logic.test.ts@@ -309,6 +309,42 @@ describe("orderItemsByPreferredIds", () => {ProjectId.make("project-1"),]);});++ it("honors projectOrder physical keys via getProjectOrderKey", async () => {+ // Regression guard for #1904 / the regression introduced by #2055:+ // `projectOrder` is populated with physical keys (envId + cwd-derived)+ // by the store and by drag-end handlers. Readers must identify projects+ // with the same key format, or manual sort silently snaps back.+ const { getProjectOrderKey } = await import("../logicalProject");+ const projects = [+ {+ environmentId: EnvironmentId.make("environment-local"),+ id: ProjectId.make("id-alpha"),+ cwd: "/work/alpha",+ },+ {+ environmentId: EnvironmentId.make("environment-local"),+ id: ProjectId.make("id-beta"),+ cwd: "/work/beta",+ },+ {+ environmentId: EnvironmentId.make("environment-local"),+ id: ProjectId.make("id-gamma"),+ cwd: "/work/gamma",+ },+ ];+ const ordered = orderItemsByPreferredIds({+ items: projects,+ preferredIds: [getProjectOrderKey(projects[2]!), getProjectOrderKey(projects[0]!)],+ getId: getProjectOrderKey,+ });++ expect(ordered.map((project) => project.cwd)).toEqual([+ "/work/gamma",+ "/work/alpha",+ "/work/beta",+ ]);+ });});describe("resolveAdjacentThreadId", () => {diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsxindex 8335042c1..d25f930c0 100644--- a/apps/web/src/components/Sidebar.tsx+++ b/apps/web/src/components/Sidebar.tsx@@ -168,7 +168,11 @@ import { CommandDialogTrigger } from "./ui/command";import { readEnvironmentApi } from "../environmentApi";import { useSettings, useUpdateSettings } from "~/hooks/useSettings";import { useServerKeybindings } from "../rpc/serverState";-import { derivePhysicalProjectKey, deriveProjectGroupingOverrideKey } from "../logicalProject";+import {+ derivePhysicalProjectKey,+ deriveProjectGroupingOverrideKey,+ getProjectOrderKey,+} from "../logicalProject";import {useSavedEnvironmentRegistryStore,useSavedEnvironmentRuntimeStore,@@ -2708,7 +2712,7 @@ export default function Sidebar() {return orderItemsByPreferredIds({items: projects,preferredIds: projectOrder,- getId: (project) => scopedProjectKey(scopeProjectRef(project.environmentId, project.id)),+ getId: getProjectOrderKey,});}, [projectOrder, projects]);diff --git a/apps/web/src/environments/runtime/service.ts b/apps/web/src/environments/runtime/service.tsindex 40f8f8f2c..775df0184 100644--- a/apps/web/src/environments/runtime/service.ts+++ b/apps/web/src/environments/runtime/service.ts@@ -61,7 +61,11 @@ import { useTerminalStateStore } from "~/terminalStateStore";import { useUiStateStore } from "~/uiStateStore";import { WsTransport } from "../../rpc/wsTransport";import { createWsRpcClient, type WsRpcClient } from "../../rpc/wsRpcClient";-import { derivePhysicalProjectKey } from "../../logicalProject";+import {+ deriveLogicalProjectKeyFromSettings,+ derivePhysicalProjectKey,+} from "../../logicalProject";+import { getClientSettings } from "~/hooks/useSettings";type EnvironmentServiceState = {readonly queryClient: QueryClient;@@ -468,9 +472,11 @@ function coalesceOrchestrationUiEvents(function syncProjectUiFromStore() {const projects = selectProjectsAcrossEnvironments(useStore.getState());+ const clientSettings = getClientSettings();useUiStateStore.getState().syncProjects(projects.map((project) => ({key: derivePhysicalProjectKey(project),+ logicalKey: deriveLogicalProjectKeyFromSettings(project, clientSettings),cwd: project.cwd,})),);@@ -541,9 +547,11 @@ function applyRecoveredEventBatch(useStore.getState().applyOrchestrationEvents(uiEvents, environmentId);if (needsProjectUiSync) {const projects = selectProjectsAcrossEnvironments(useStore.getState());+ const clientSettings = getClientSettings();useUiStateStore.getState().syncProjects(projects.map((project) => ({key: derivePhysicalProjectKey(project),+ logicalKey: deriveLogicalProjectKeyFromSettings(project, clientSettings),cwd: project.cwd,})),);diff --git a/apps/web/src/hooks/useHandleNewThread.ts b/apps/web/src/hooks/useHandleNewThread.tsindex d512b6c7e..3630171bf 100644--- a/apps/web/src/hooks/useHandleNewThread.ts+++ b/apps/web/src/hooks/useHandleNewThread.ts@@ -10,7 +10,7 @@ import {} from "../composerDraftStore";import { newDraftId, newThreadId } from "../lib/utils";import { orderItemsByPreferredIds } from "../components/Sidebar.logic";-import { deriveLogicalProjectKeyFromSettings } from "../logicalProject";+import { deriveLogicalProjectKeyFromSettings, getProjectOrderKey } from "../logicalProject";import { selectProjectsAcrossEnvironments, useStore } from "../store";import { createThreadSelectorByRef } from "../storeSelectors";import { resolveThreadRouteTarget } from "../threadRoutes";@@ -169,7 +169,7 @@ export function useHandleNewThread() {return orderItemsByPreferredIds({items: projects,preferredIds: projectOrder,- getId: (project) => scopedProjectKey(scopeProjectRef(project.environmentId, project.id)),+ getId: getProjectOrderKey,});}, [projectOrder, projects]);const handleNewThread = useNewThreadState();diff --git a/apps/web/src/hooks/useSettings.ts b/apps/web/src/hooks/useSettings.tsindex 18b2668a6..37a6872bd 100644--- a/apps/web/src/hooks/useSettings.ts+++ b/apps/web/src/hooks/useSettings.ts@@ -123,6 +123,15 @@ function splitPatch(patch: Partial<UnifiedSettings>): {* only re-render when the slice they care about changes.*/+/**+ * Non-hook accessor for the current merged client settings snapshot.+ * Used by non-React code paths (e.g. runtime services) that need the latest+ * settings without subscribing.+ */+export function getClientSettings(): ClientSettings {+ return getClientSettingsSnapshot();+}+export function useSettings<T = UnifiedSettings>(selector?: (s: UnifiedSettings) => T): T {const serverSettings = useServerSettings();const clientSettings = useSyncExternalStore(diff --git a/apps/web/src/logicalProject.ts b/apps/web/src/logicalProject.tsindex d30bb60ca..f19b64ac8 100644--- a/apps/web/src/logicalProject.ts+++ b/apps/web/src/logicalProject.ts@@ -65,6 +65,13 @@ export function deriveProjectGroupingOverrideKey(return derivePhysicalProjectKey(project);}+// Key under which a project's manual sort order (projectOrder) is stored.+// Must stay aligned with the writer side in `uiStateStore.syncProjects` and+// the drag handlers in `Sidebar` so readers and writers agree.+export function getProjectOrderKey(project: Pick<Project, "environmentId" | "cwd">): string {+ return derivePhysicalProjectKey(project);+}+export function resolveProjectGroupingMode(project: Pick<Project, "environmentId" | "cwd">,settings: ProjectGroupingSettings,diff --git a/apps/web/src/uiStateStore.test.ts b/apps/web/src/uiStateStore.test.tsindex c906bbc1d..f63208d9b 100644--- a/apps/web/src/uiStateStore.test.ts+++ b/apps/web/src/uiStateStore.test.ts@@ -1,9 +1,13 @@import { ProjectId, ThreadId } from "@t3tools/contracts";-import { describe, expect, it } from "vitest";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";import {clearThreadUi,+ hydratePersistedProjectState,markThreadUnread,+ PERSISTED_STATE_KEY,+ type PersistedUiState,+ persistState,reorderProjects,setProjectExpanded,setThreadChangedFilesExpanded,@@ -183,40 +187,43 @@ describe("uiStateStore pure functions", () => {});const next = syncProjects(initialState, [- { key: project1, cwd: "/tmp/project-1" },- { key: project2, cwd: "/tmp/project-2" },- { key: project3, cwd: "/tmp/project-3" },+ { key: project1, logicalKey: project1, cwd: "/tmp/project-1" },+ { key: project2, logicalKey: project2, cwd: "/tmp/project-2" },+ { key: project3, logicalKey: project3, cwd: "/tmp/project-3" },]);expect(next.projectOrder).toEqual([project2, project1, project3]);expect(next.projectExpandedById[project2]).toBe(false);});- it("syncProjects preserves manual order when a project is recreated with the same cwd", () => {- const oldProject1 = ProjectId.make("project-1");- const oldProject2 = ProjectId.make("project-2");- const recreatedProject2 = ProjectId.make("project-2b");+ it("syncProjects preserves manual order across project id churn at the same cwd", () => {+ // Under the current design, physical key and logical key are both+ // cwd-derived, so an internal project-id change doesn't alter the store+ // keys. This test locks in that stability: re-syncing the same cwds keeps+ // manual order and collapse state.+ const keyProject1 = "env-local:/tmp/project-1";+ const keyProject2 = "env-local:/tmp/project-2";const initialState = syncProjects(makeUiState({projectExpandedById: {- [oldProject1]: true,- [oldProject2]: false,+ [keyProject1]: true,+ [keyProject2]: false,},- projectOrder: [oldProject2, oldProject1],+ projectOrder: [keyProject2, keyProject1],}),[- { key: oldProject1, cwd: "/tmp/project-1" },- { key: oldProject2, cwd: "/tmp/project-2" },+ { key: keyProject1, logicalKey: keyProject1, cwd: "/tmp/project-1" },+ { key: keyProject2, logicalKey: keyProject2, cwd: "/tmp/project-2" },],);const next = syncProjects(initialState, [- { key: oldProject1, cwd: "/tmp/project-1" },- { key: recreatedProject2, cwd: "/tmp/project-2" },+ { key: keyProject1, logicalKey: keyProject1, cwd: "/tmp/project-1" },+ { key: keyProject2, logicalKey: keyProject2, cwd: "/tmp/project-2" },]);- expect(next.projectOrder).toEqual([recreatedProject2, oldProject1]);- expect(next.projectExpandedById[recreatedProject2]).toBe(false);+ expect(next.projectOrder).toEqual([keyProject2, keyProject1]);+ expect(next.projectExpandedById[keyProject2]).toBe(false);});it("syncProjects returns a new state when only project cwd changes", () => {@@ -228,16 +235,70 @@ describe("uiStateStore pure functions", () => {},projectOrder: [project1],}),- [{ key: project1, cwd: "/tmp/project-1" }],+ [{ key: project1, logicalKey: project1, cwd: "/tmp/project-1" }],);- const next = syncProjects(initialState, [{ key: project1, cwd: "/tmp/project-1-renamed" }]);+ const next = syncProjects(initialState, [+ { key: project1, logicalKey: project1, cwd: "/tmp/project-1-renamed" },+ ]);expect(next).not.toBe(initialState);expect(next.projectOrder).toEqual([project1]);expect(next.projectExpandedById[project1]).toBe(false);});+ it("syncProjects keys projectExpandedById by the logical key, not the physical key", () => {+ // In repository grouping mode, multiple physical projects (different+ // environments or different repo-relative paths) collapse into one+ // logical group. The group's expand state must be keyed by the logical+ // key so clicks on the grouped row toggle the shared state, and so the+ // state survives subsequent syncProjects calls (which rebuild the map+ // from incoming inputs).+ const physicalLocal = "env-local:/repo/project";+ const physicalRemote = "env-remote:/repo/project";+ const logicalKey = "repo-canonical-key";++ const initial = syncProjects(makeUiState(), [+ { key: physicalLocal, logicalKey, cwd: "/repo/project" },+ { key: physicalRemote, logicalKey, cwd: "/repo/project" },+ ]);++ expect(initial.projectExpandedById).toEqual({ [logicalKey]: true });++ const afterCollapse = { ...initial, projectExpandedById: { [logicalKey]: false } };+ const next = syncProjects(afterCollapse, [+ { key: physicalLocal, logicalKey, cwd: "/repo/project" },+ { key: physicalRemote, logicalKey, cwd: "/repo/project" },+ ]);++ expect(next.projectExpandedById[logicalKey]).toBe(false);+ });++ it("syncProjects preserves expand state when a project's logical key changes", () => {+ // Example: late-arriving repo metadata flips grouping identity from the+ // physical key to a canonical repository key. The row did not actually+ // change, so the user's collapse choice must carry over.+ const physicalKey = "env-local:/repo/project";+ const previousLogicalKey = physicalKey;+ const nextLogicalKey = "repo-canonical-key";++ const initial = syncProjects(makeUiState(), [+ { key: physicalKey, logicalKey: previousLogicalKey, cwd: "/repo/project" },+ ]);++ expect(initial.projectExpandedById[previousLogicalKey]).toBe(true);++ const afterCollapse = {+ ...initial,+ projectExpandedById: { [previousLogicalKey]: false },+ };+ const next = syncProjects(afterCollapse, [+ { key: physicalKey, logicalKey: nextLogicalKey, cwd: "/repo/project" },+ ]);++ expect(next.projectExpandedById[nextLogicalKey]).toBe(false);+ });+it("syncThreads prunes missing thread UI state", () => {const thread1 = ThreadId.make("thread-1");const thread2 = ThreadId.make("thread-2");@@ -346,3 +407,156 @@ describe("uiStateStore pure functions", () => {expect(next.threadChangedFilesExpandedById).toEqual({});});});++describe("uiStateStore persistence round-trip", () => {+ function createLocalStorageStub(): Storage {+ const store = new Map<string, string>();+ return {+ clear: () => {+ store.clear();+ },+ getItem: (key) => store.get(key) ?? null,+ key: (index) => [...store.keys()][index] ?? null,+ get length() {+ return store.size;+ },+ removeItem: (key) => {+ store.delete(key);+ },+ setItem: (key, value) => {+ store.set(key, value);+ },+ };+ }++ let localStorageStub: Storage;++ beforeEach(() => {+ localStorageStub = createLocalStorageStub();+ vi.stubGlobal("window", { localStorage: localStorageStub });+ vi.stubGlobal("localStorage", localStorageStub);+ // Reset module-level persistence state so tests don't bleed into each other.+ hydratePersistedProjectState({ collapsedProjectCwds: [], expandedProjectCwds: [] });+ });++ afterEach(() => {+ vi.unstubAllGlobals();+ });++ it("preserves all-collapsed project state across restart", () => {+ // Regression: pre-fix, persistState only wrote `expandedProjectCwds`, so+ // an empty array on rehydrate was indistinguishable from a fresh install+ // and the syncProjects fallback re-expanded every row.+ const projectA = { key: "kA", logicalKey: "kA", cwd: "/projA" };+ const projectB = { key: "kB", logicalKey: "kB", cwd: "/projB" };++ let state = syncProjects(makeUiState(), [projectA, projectB]);+ state = setProjectExpanded(state, projectA.key, false);+ state = setProjectExpanded(state, projectB.key, false);+ persistState(state);++ const persisted = JSON.parse(+ localStorageStub.getItem(PERSISTED_STATE_KEY) ?? "{}",+ ) as PersistedUiState;+ hydratePersistedProjectState(persisted);+ const rehydrated = syncProjects(makeUiState(), [projectA, projectB]);++ expect(rehydrated.projectExpandedById).toEqual({+ [projectA.key]: false,+ [projectB.key]: false,+ });+ });++ it("respects mixed expand state on rehydrate and defaults new projects to expanded", () => {+ const projectA = { key: "kA", logicalKey: "kA", cwd: "/projA" };+ const projectB = { key: "kB", logicalKey: "kB", cwd: "/projB" };+ const projectC = { key: "kC", logicalKey: "kC", cwd: "/projC" };++ let state = syncProjects(makeUiState(), [projectA, projectB]);+ state = setProjectExpanded(state, projectB.key, false);+ persistState(state);++ const persisted = JSON.parse(+ localStorageStub.getItem(PERSISTED_STATE_KEY) ?? "{}",+ ) as PersistedUiState;+ hydratePersistedProjectState(persisted);+ const rehydrated = syncProjects(makeUiState(), [projectA, projectB, projectC]);++ expect(rehydrated.projectExpandedById).toEqual({+ [projectA.key]: true,+ [projectB.key]: false,+ [projectC.key]: true,+ });+ });++ it("preserves legacy not-in-expanded-list = collapsed for one upgrade session", () => {+ // Pre-fix shape only stored expandedProjectCwds. Absence of+ // collapsedProjectCwds opts the session into the legacy fallback so+ // upgrade users do not see previously collapsed rows pop open.+ hydratePersistedProjectState({+ expandedProjectCwds: ["/projA"],+ });++ const rehydrated = syncProjects(makeUiState(), [+ { key: "kA", logicalKey: "kA", cwd: "/projA" },+ { key: "kB", logicalKey: "kB", cwd: "/projB" },+ ]);++ expect(rehydrated.projectExpandedById).toEqual({+ kA: true,+ kB: false,+ });+ });++ it("preserves manual project order across restart", () => {+ const projectA = { key: "kOrderA", logicalKey: "kOrderA", cwd: "/order-projA" };+ const projectB = { key: "kOrderB", logicalKey: "kOrderB", cwd: "/order-projB" };+ const projectC = { key: "kOrderC", logicalKey: "kOrderC", cwd: "/order-projC" };++ let state = syncProjects(makeUiState(), [projectA, projectB, projectC]);+ state = reorderProjects(state, [projectC.key], [projectA.key]);+ expect(state.projectOrder).toEqual([projectC.key, projectA.key, projectB.key]);+ persistState(state);++ const persisted = JSON.parse(+ localStorageStub.getItem(PERSISTED_STATE_KEY) ?? "{}",+ ) as PersistedUiState;+ expect(persisted.projectOrderCwds).toEqual([projectC.cwd, projectA.cwd, projectB.cwd]);++ hydratePersistedProjectState(persisted);+ // Fresh state (empty projectOrder) so syncProjects derives order from+ // persistedProjectOrderCwds rather than the in-memory projectOrder branch.+ const rehydrated = syncProjects(makeUiState(), [projectA, projectB, projectC]);++ expect(rehydrated.projectOrder).toEqual([projectC.key, projectA.key, projectB.key]);+ });++ it("preserves expand state across restart when project's logical key changes", () => {+ // After restart, in-memory previousExpandedById is empty, so the+ // previousLogicalKey-to-state bridge in syncProjects cannot help. The+ // persisted-cwd fallback is the only mechanism that can carry collapse+ // state across a restart that also flips a project into a new logical+ // group (e.g. late-arriving repo metadata). This locks in that path.+ const physicalKey = "env-local:/lk-restart-proj";+ const previousLogicalKey = physicalKey;+ const cwd = "/lk-restart-proj";++ let state = syncProjects(makeUiState(), [+ { key: physicalKey, logicalKey: previousLogicalKey, cwd },+ ]);+ state = setProjectExpanded(state, previousLogicalKey, false);+ persistState(state);++ const persisted = JSON.parse(+ localStorageStub.getItem(PERSISTED_STATE_KEY) ?? "{}",+ ) as PersistedUiState;+ hydratePersistedProjectState(persisted);++ const nextLogicalKey = "lk-restart-canonical";+ const rehydrated = syncProjects(makeUiState(), [+ { key: physicalKey, logicalKey: nextLogicalKey, cwd },+ ]);++ expect(rehydrated.projectExpandedById[nextLogicalKey]).toBe(false);+ });+});diff --git a/apps/web/src/uiStateStore.ts b/apps/web/src/uiStateStore.tsindex 7ae723206..8bd65ffc5 100644--- a/apps/web/src/uiStateStore.ts+++ b/apps/web/src/uiStateStore.ts@@ -1,7 +1,7 @@import { Debouncer } from "@tanstack/react-pacer";import { create } from "zustand";-const PERSISTED_STATE_KEY = "t3code:ui-state:v1";+export const PERSISTED_STATE_KEY = "t3code:ui-state:v1";const LEGACY_PERSISTED_STATE_KEYS = ["t3code:renderer-state:v8","t3code:renderer-state:v7",@@ -15,7 +15,8 @@ const LEGACY_PERSISTED_STATE_KEYS = ["codething:renderer-state:v1",] as const;-interface PersistedUiState {+export interface PersistedUiState {+ collapsedProjectCwds?: string[];expandedProjectCwds?: string[];projectOrderCwds?: string[];threadChangedFilesExpandedById?: Record<string, Record<string, boolean>>;@@ -34,7 +35,10 @@ export interface UiThreadState {export interface UiState extends UiProjectState, UiThreadState {}export interface SyncProjectInput {+ /** Physical project key (env + cwd). Used for manual sort order. */key: string;+ /** Logical group key. Used for expand/collapse state. */+ logicalKey: string;cwd: string;}@@ -50,9 +54,17 @@ const initialState: UiState = {threadChangedFilesExpandedById: {},};+const persistedCollapsedProjectCwds = new Set<string>();const persistedExpandedProjectCwds = new Set<string>();const persistedProjectOrderCwds: string[] = [];+// Pre-fix persisted shape only listed expanded cwds, so anything not listed+// was treated as collapsed. Track whether the loaded blob carried the new+// `collapsedProjectCwds` field so we can preserve that legacy semantic for+// one session after upgrade, until persistState rewrites in the new shape.+let persistedProjectStateUsesLegacyShape = false;const currentProjectCwdById = new Map<string, string>();+const currentProjectCwdsByLogicalKey = new Map<string, string[]>();+const currentLogicalKeyByPhysicalKey = new Map<string, string>();let legacyKeysCleanedUp = false;function readPersistedState(): UiState {@@ -113,9 +125,16 @@ function sanitizePersistedThreadChangedFilesExpanded(return nextState;}-function hydratePersistedProjectState(parsed: PersistedUiState): void {+export function hydratePersistedProjectState(parsed: PersistedUiState): void {+ persistedCollapsedProjectCwds.clear();persistedExpandedProjectCwds.clear();persistedProjectOrderCwds.length = 0;+ persistedProjectStateUsesLegacyShape = !Array.isArray(parsed.collapsedProjectCwds);+ for (const cwd of parsed.collapsedProjectCwds ?? []) {+ if (typeof cwd === "string" && cwd.length > 0) {+ persistedCollapsedProjectCwds.add(cwd);+ }+ }for (const cwd of parsed.expandedProjectCwds ?? []) {if (typeof cwd === "string" && cwd.length > 0) {persistedExpandedProjectCwds.add(cwd);@@ -128,17 +147,20 @@ function hydratePersistedProjectState(parsed: PersistedUiState): void {}}-function persistState(state: UiState): void {+export function persistState(state: UiState): void {if (typeof window === "undefined") {return;}try {+ // Persist collapsed cwds explicitly so an empty/missing field unambiguously+ // means "first install" rather than "user collapsed everything"; without+ // this, the syncProjects fallback would re-expand all rows on next launch.+ const collapsedProjectCwds = Object.entries(state.projectExpandedById)+ .filter(([, expanded]) => !expanded)+ .flatMap(([logicalKey]) => currentProjectCwdsByLogicalKey.get(logicalKey) ?? []);const expandedProjectCwds = Object.entries(state.projectExpandedById).filter(([, expanded]) => expanded)- .flatMap(([projectId]) => {- const cwd = currentProjectCwdById.get(projectId);- return cwd ? [cwd] : [];- });+ .flatMap(([logicalKey]) => currentProjectCwdsByLogicalKey.get(logicalKey) ?? []);const projectOrderCwds = state.projectOrder.flatMap((projectId) => {const cwd = currentProjectCwdById.get(projectId);return cwd ? [cwd] : [];@@ -154,6 +176,7 @@ function persistState(state: UiState): void {window.localStorage.setItem(PERSISTED_STATE_KEY,JSON.stringify({+ collapsedProjectCwds,expandedProjectCwds,projectOrderCwds,threadChangedFilesExpandedById,@@ -211,12 +234,40 @@ function nestedBooleanRecordsEqual(export function syncProjects(state: UiState, projects: readonly SyncProjectInput[]): UiState {const previousProjectCwdById = new Map(currentProjectCwdById);- const previousProjectIdByCwd = new Map(- [...previousProjectCwdById.entries()].map(([projectId, cwd]) => [cwd, projectId] as const),- );+ const previousLogicalKeyByPhysicalKey = new Map(currentLogicalKeyByPhysicalKey);currentProjectCwdById.clear();+ currentLogicalKeyByPhysicalKey.clear();for (const project of projects) {currentProjectCwdById.set(project.key, project.cwd);+ currentLogicalKeyByPhysicalKey.set(project.key, project.logicalKey);+ }+ currentProjectCwdsByLogicalKey.clear();+ for (const project of projects) {+ const cwds = currentProjectCwdsByLogicalKey.get(project.logicalKey);+ if (cwds) {+ if (!cwds.includes(project.cwd)) {+ cwds.push(project.cwd);+ }+ } else {+ currentProjectCwdsByLogicalKey.set(project.logicalKey, [project.cwd]);+ }+ }+ // Build reverse map: for each new logical key, which previous logical keys+ // did its member projects live under? Lets us preserve expand state when a+ // project's logical key changes (e.g. late-arriving repo metadata flips the+ // group identity).+ const previousLogicalKeysByNewLogicalKey = new Map<string, Set<string>>();+ for (const project of projects) {+ const previousLogicalKey = previousLogicalKeyByPhysicalKey.get(project.key);+ if (!previousLogicalKey || previousLogicalKey === project.logicalKey) {+ continue;+ }+ const set = previousLogicalKeysByNewLogicalKey.get(project.logicalKey);+ if (set) {+ set.add(previousLogicalKey);+ } else {+ previousLogicalKeysByNewLogicalKey.set(project.logicalKey, new Set([previousLogicalKey]));+ }}const cwdMappingChanged =previousProjectCwdById.size !== currentProjectCwdById.size ||@@ -228,14 +279,38 @@ export function syncProjects(state: UiState, projects: readonly SyncProjectInputpersistedProjectOrderCwds.map((cwd, index) => [cwd, index] as const),);const mappedProjects = projects.map((project, index) => {- const previousProjectIdForCwd = previousProjectIdByCwd.get(project.cwd);- const expanded =- previousExpandedById[project.key] ??- (previousProjectIdForCwd ? previousExpandedById[previousProjectIdForCwd] : undefined) ??- (persistedExpandedProjectCwds.size > 0- ? persistedExpandedProjectCwds.has(project.cwd)- : true);- nextExpandedById[project.key] = expanded;+ if (!(project.logicalKey in nextExpandedById)) {+ const groupCwds = currentProjectCwdsByLogicalKey.get(project.logicalKey) ?? [project.cwd];+ const fallbackFromPreviousLogicalKey = (() => {+ const previousKeys = previousLogicalKeysByNewLogicalKey.get(project.logicalKey);+ if (!previousKeys) {+ return undefined;+ }+ for (const previousKey of previousKeys) {+ if (previousKey in previousExpandedById) {+ return previousExpandedById[previousKey];+ }+ }+ return undefined;+ })();+ const fallbackFromPersistedShape = (() => {+ if (groupCwds.some((cwd) => persistedExpandedProjectCwds.has(cwd))) {+ return true;+ }+ if (groupCwds.some((cwd) => persistedCollapsedProjectCwds.has(cwd))) {+ return false;+ }+ if (persistedProjectStateUsesLegacyShape && persistedExpandedProjectCwds.size > 0) {+ return false;+ }+ return true;+ })();+ const expanded =+ previousExpandedById[project.logicalKey] ??+ fallbackFromPreviousLogicalKey ??+ fallbackFromPersistedShape;+ nextExpandedById[project.logicalKey] = expanded;+ }return {id: project.key,cwd: project.cwd,@@ -246,6 +321,7 @@ export function syncProjects(state: UiState, projects: readonly SyncProjectInputconst nextProjectOrder =state.projectOrder.length > 0? (() => {+ const currentProjectIds = new Set(mappedProjects.map((project) => project.id));const nextProjectIdByCwd = new Map(mappedProjects.map((project) => [project.cwd, project.id] as const),);@@ -254,7 +330,7 @@ export function syncProjects(state: UiState, projects: readonly SyncProjectInputfor (const projectId of state.projectOrder) {const matchedProjectId =- (projectId in nextExpandedById ? projectId : undefined) ??+ (currentProjectIds.has(projectId) ? projectId : undefined) ??(() => {const previousCwd = previousProjectCwdById.get(projectId);return previousCwd ? nextProjectIdByCwd.get(previousCwd) : undefined;