@brimveyn/aimux 1.21.0 → 1.22.2

package/src/state/actions.ts

@@ -0,0 +1,342 @@
+// Every action the reducer accepts, grouped by the slice of state it touches.
+//
+// Split from `types.ts` so the state shapes and the messages that change them
+// are separate files: the shapes are read by the whole app, this union only by
+// the reducer and the things that dispatch into it.
+
+import type { ModeId } from '@brimveyn/aimux-config'
+
+import type { LayoutNode, SplitDirection } from './layout-tree'
+import type {
+  AssistantId,
+  BarSide,
+  BranchDivergence,
+  DiffData,
+  DirectoryResult,
+  DiscoveredRepo,
+  FocusMode,
+  GitFileSection,
+  GitPanelError,
+  GitPaneState,
+  GitRefreshPayload,
+  PendingWorkspaceLaunch,
+  ProjectRecord,
+  ProjectSnapshotV1,
+  ProjectStatus,
+  SnippetRecord,
+  TabActivity,
+  TabSession,
+  TerminalModeState,
+  TerminalSnapshot,
+  WorkspaceRecord,
+} from './types'
+
+export type ModalAction =
+  | { type: 'move-modal-cursor'; delta?: number; to?: 'home' | 'end' }
+  | {
+      type: 'open-new-tab-modal'
+      pendingWorkspace?: PendingWorkspaceLaunch
+      pendingPrompt?: string
+    }
+  | { type: 'open-edit-custom-command'; assistantId: AssistantId }
+  | { type: 'open-help-modal'; scope?: ModeId }
+  | { type: 'open-split-picker'; direction: SplitDirection }
+  | { type: 'open-project-picker' }
+  | {
+      type: 'open-project-name-modal'
+      projectTargetId?: string
+      initialName?: string
+      returnToProjectPicker?: boolean
+    }
+  | { type: 'close-modal' }
+  | { type: 'move-modal-selection'; delta: number }
+  | { type: 'update-command-edit'; char: string }
+  | { type: 'cancel-command-edit' }
+  | { type: 'open-create-project-modal'; returnToProjectPicker: boolean }
+  | { type: 'open-create-workspace-modal' }
+  | { type: 'set-create-workspace-base-branches'; branches: string[]; defaultBranch?: string }
+  | { type: 'set-create-workspace-branch-error'; message: string | null }
+  | { type: 'switch-create-workspace-field' }
+  | { type: 'set-directory-results'; results: DirectoryResult[] }
+  | { type: 'switch-create-project-field' }
+  | { type: 'select-directory' }
+  | { type: 'open-rename-tab-modal' }
+  | {
+      type: 'open-rename-workspace-modal'
+      projectId: string
+      workspaceId: string
+      initialName: string
+    }
+  | { type: 'open-snippet-picker'; returnTo?: FocusMode }
+  | { type: 'open-snippet-editor'; snippetId?: string }
+  | { type: 'set-help-entry-count'; count: number }
+  | { type: 'set-theme-entry-count'; count: number }
+  | { type: 'open-theme-picker'; returnTo?: FocusMode }
+  | { type: 'open-update-available-modal'; currentVersion: string; latestVersion: string }
+  | { type: 'set-modal-selection-index'; index: number }
+  | { type: 'open-ai-usage-modal' }
+  | { type: 'open-workspace-move-modal'; sourceWorkspaceId: string }
+  | { type: 'toggle-workspace-move-delete' }
+  | { type: 'set-workspace-move-stats'; dirtyFiles: Record<string, number> }
+  | {
+      type: 'open-workspace-move-confirm'
+      variant: 'stash-target' | 'keep-conflicts'
+      files: string[]
+      projectId: string
+      sourceWorkspaceId: string
+      targetWorkspaceId: string
+      deleteSource: boolean
+      sourceLabel: string
+      targetLabel: string
+    }
+  | {
+      type: 'open-workspace-delete-confirm'
+      projectId: string
+      workspaceId: string
+      workspaceLabel: string
+      reason: string
+      closeTabs: boolean
+      force: boolean
+    }
+  | { type: 'open-flash-jump-modal' }
+  | { type: 'clear-flash-jump-pending' }
+
+export type ProjectAction =
+  | {
+      type: 'load-project'
+      projectId: string
+      projectSnapshot?: ProjectSnapshotV1
+      forceDisconnected?: boolean
+    }
+  | { type: 'set-projects'; projects: ProjectRecord[] }
+  | { type: 'create-project-record'; project: ProjectRecord }
+  | { type: 'rename-project-record'; projectId: string; name: string }
+  | { type: 'delete-project-record'; projectId: string; openProjectPicker?: boolean }
+  | { type: 'reorder-projects'; orderedIds: string[] }
+  | { type: 'reorder-active-project'; delta: number }
+  | { type: 'set-project-status'; projectId: string; status: ProjectStatus }
+  /** What a workspace's assistants are doing. `done` is owned by the reducer,
+   *  so this carries only the two flags derived from tab statuses. */
+  | { type: 'set-workspace-activity'; workspaceId: string; working: boolean; waiting: boolean }
+  /** An assistant in this workspace finished a turn and nobody has looked yet. */
+  | { type: 'mark-workspace-done'; workspaceId: string }
+  /** The tab that rang: it finished a turn while the user was elsewhere. */
+  | { type: 'mark-tab-unseen'; tabId: string }
+  | {
+      type: 'add-workspace-record'
+      projectId: string
+      workspace: WorkspaceRecord
+      activate?: boolean
+    }
+  | { type: 'set-active-workspace'; projectId: string; workspaceId: string }
+  | {
+      type: 'update-workspace-record'
+      projectId: string
+      workspaceId: string
+      patch: Partial<WorkspaceRecord>
+    }
+
+export type TabAction =
+  | { type: 'add-tab'; tab: TabSession }
+  | {
+      type: 'hydrate-project'
+      tabs: TabSession[]
+      activeTabId: string | null
+      layoutTree?: LayoutNode | null
+      layoutTrees?: Record<string, LayoutNode>
+      tabGroupMap?: Record<string, string>
+    }
+  | { type: 'close-tab'; tabId: string }
+  | { type: 'close-active-tab' }
+  | { type: 'set-active-tab'; tabId: string }
+  | { type: 'move-active-tab'; delta: number }
+  | { type: 'reorder-active-tab'; delta: number }
+  | { type: 'reorder-tabs'; orderedTabIds: string[] }
+  | { type: 'reset-tab-project'; tabId: string }
+  | {
+      type: 'rename-tab'
+      tabId: string
+      title: string
+      autoRenameStatus?: 'eligible' | 'attempted'
+    }
+  | {
+      type: 'update-tab-metadata'
+      tabId: string
+      title?: string
+      autoRenameStatus?: 'eligible' | 'attempted'
+      /** Set to false to promote a hidden tab into the normal tab strip. */
+      hidden?: boolean
+    }
+  | { type: 'append-tab-buffer'; tabId: string; chunk: string }
+  | {
+      type: 'replace-tab-viewport'
+      tabId: string
+      viewport: TerminalSnapshot
+      terminalModes: TerminalModeState
+      source?: 'resize' | 'scroll' | 'data' | 'switch'
+    }
+  | { type: 'set-tab-activity'; tabId: string; activity?: TabActivity }
+  | { type: 'set-tab-error'; tabId: string; message: string }
+
+export type LayoutAction =
+  | {
+      type: 'split-pane'
+      direction: SplitDirection
+      newTab: TabSession
+    }
+  | { type: 'close-pane'; tabId: string }
+  | {
+      type: 'focus-pane-direction'
+      direction: 'left' | 'right' | 'up' | 'down'
+    }
+  | {
+      type: 'resize-pane'
+      tabId: string
+      delta: number
+      axis?: SplitDirection
+    }
+  | {
+      type: 'set-split-ratio'
+      tabId: string
+      ratio: number
+      axis?: SplitDirection
+    }
+
+export type UIAction =
+  | { type: 'toggle-bar'; side: BarSide }
+  | { type: 'resize-bar'; side: BarSide; delta: number }
+  | { type: 'set-bar-width'; side: BarSide; width: number }
+  | { type: 'toggle-widget'; widgetId: string }
+  | { type: 'move-widget'; widgetId: string; side: BarSide; index: number }
+  | { type: 'set-bar-boundary'; side: BarSide; index: number; ratio: number }
+  | { type: 'resize-widget'; widgetId: string; delta: number }
+  | { type: 'set-focus-mode'; focusMode: FocusMode }
+  | { type: 'set-terminal-size'; cols: number; rows: number }
+  | { type: 'resize-git-diff-pane'; delta: number }
+  | { type: 'set-pending-chords'; chords: string[] | null }
+  | { type: 'toggle-project-bar' }
+
+export type SettingsAction =
+  | { type: 'enter-settings' }
+  | { type: 'exit-settings' }
+  | { type: 'settings-focus-pane'; pane: 'nav' | 'rows' }
+  | { type: 'settings-move-selection'; delta: -1 | 1 }
+  | { type: 'settings-select-section'; sectionId: string }
+  | { type: 'settings-select-row'; rowIndex: number }
+  | { type: 'open-settings-search' }
+  | { type: 'open-setting-text-modal'; settingId: string; label: string; value: string }
+
+export type GitPanelAction =
+  | { type: 'git-refresh-success'; payload: GitRefreshPayload }
+  | { type: 'git-refresh-error'; kind: GitPanelError }
+  | { type: 'git-panel-reset' }
+  | { type: 'set-workspace-divergence'; divergence: Record<string, BranchDivergence> }
+  | { type: 'set-git-pane'; patch: Partial<GitPaneState> }
+
+export type AutoCommitAction =
+  | {
+      type: 'auto-commit-generation-started'
+      projectId: string
+      tabId: string
+      workingTreeHash: string
+      abortController: AbortController
+      startedAt: number
+    }
+  | {
+      type: 'auto-commit-generation-ready'
+      projectId: string
+      workingTreeHash: string
+      title: string
+      body: string
+      generatedAt: number
+    }
+  | { type: 'auto-commit-clear'; projectId: string }
+
+export type GitModeAction =
+  | { type: 'enter-git-mode' }
+  | { type: 'exit-git-mode' }
+  | { type: 'git-mode-move-selection'; delta: -1 | 1 }
+  | { type: 'git-mode-move-file-selection'; delta: -1 | 1 }
+  | { type: 'git-mode-select-entry-by-key'; key: string }
+  | { type: 'git-mode-toggle-folder'; key: string }
+  | { type: 'git-mode-toggle-selected-folder' }
+  | { type: 'git-mode-collapse-selection' }
+  | { type: 'git-mode-expand-selection' }
+  | { type: 'git-mode-toggle-file-list-mode' }
+  | { type: 'git-mode-toggle-tree-compaction' }
+  | { type: 'git-mode-set-diff'; key: string; diff: DiffData; hash: string }
+  | {
+      type: 'git-mode-set-parsed'
+      key: string
+      hash: string
+      file: unknown
+    }
+  | {
+      type: 'git-mode-set-highlights'
+      key: string
+      hash: string
+      themeId: string
+      add: unknown
+      del: unknown
+    }
+  | {
+      type: 'git-mode-merge-highlights'
+      key: string
+      hash: string
+      themeId: string
+      add: { start: number; tokens: unknown }[]
+      del: { start: number; tokens: unknown }[]
+    }
+  | { type: 'git-mode-invalidate-diffs'; paths: string[] }
+  | { type: 'git-mode-set-loading'; key: string; loading: boolean }
+  | { type: 'git-mode-set-pending-delete'; path: string | null }
+  | { type: 'git-mode-clear-diff-cache'; path: string }
+  | { type: 'git-mode-set-message'; message: string | null }
+  | { type: 'snippet-picker-set-message'; message: string | null }
+  | { type: 'git-mode-toggle-diff-view' }
+  | { type: 'git-mode-toggle-review-base' }
+  | { type: 'git-mode-shift-head-offset'; delta: number }
+  | { type: 'git-mode-set-head-offset'; offset: number }
+  | {
+      type: 'git-mode-fold-adjust'
+      key: string
+      foldId: string
+      side: 'top' | 'bottom'
+      delta: number
+    }
+  | { type: 'git-mode-fold-set'; key: string; foldId: string; top: number; bottom: number }
+  | { type: 'git-mode-fold-toggle-all'; key: string }
+  | {
+      type: 'git-mode-optimistic-move'
+      path: string
+      fromSection: GitFileSection
+      toSection: GitFileSection | null
+    }
+  | { type: 'open-git-commit-modal'; projectId?: string }
+  | { type: 'git-commit-enter-confirm' }
+  | { type: 'git-commit-leave-confirm' }
+  | { type: 'git-commit-enter-generating'; projectId: string }
+  | { type: 'git-commit-leave-generating' }
+  | { type: 'git-commit-use-background-suggestion'; projectId: string }
+
+export type DataAction =
+  | { type: 'set-snippets'; snippets: SnippetRecord[] }
+  | { type: 'delete-snippet'; snippetId: string }
+  | { type: 'set-custom-commands'; customCommands: Record<AssistantId, string> }
+
+export type MultiRepoAction =
+  | { type: 'multi-repo-set-repos'; repos: DiscoveredRepo[] }
+  | { type: 'multi-repo-clear' }
+
+export type AppAction =
+  | ModalAction
+  | ProjectAction
+  | TabAction
+  | LayoutAction
+  | UIAction
+  | SettingsAction
+  | DataAction
+  | GitPanelAction
+  | GitModeAction
+  | AutoCommitAction
+  | MultiRepoAction

package/src/state/app-store.ts

@@ -1,7 +1,8 @@
 import { useStore } from 'zustand'
 import { createStore } from 'zustand/vanilla'
 
-import type { AppAction, AppState } from './types'
+import type { AppAction } from './actions'
+import type { AppState } from './types'
 
 import { appReducer, createInitialState } from './store'
 

package/src/state/bars.ts

@@ -4,7 +4,7 @@ export const BAR_MIN_WIDTH = 18
 export const BAR_MAX_WIDTH = 80
 
 /** Widget ids the app knows how to render. Unknown ids are pruned on load. */
-export const KNOWN_WIDGET_IDS = ['workspaces', 'git'] as const
+export const KNOWN_WIDGET_IDS = ['projects', 'git', 'setup'] as const
 
 /** Smallest share of a bar a single widget may shrink to, as a fraction. */
 const MIN_WIDGET_SHARE = 0.1

package/src/state/dispatch-ref.ts

@@ -1,5 +1,5 @@
 import type { SideEffect } from '../input/modes/types'
-import type { AppAction } from './types'
+import type { AppAction } from './actions'
 
 type DispatchFn = (action: AppAction) => void
 type SideEffectFn = (effect: SideEffect) => void

package/src/state/layout-resize.ts

@@ -1,4 +1,4 @@
-import type { WorkspaceSnapshotV1 } from './types'
+import type { ProjectSnapshotV1 } from './types'
 
 import { computePaneRects, type LayoutNode, PANE_BORDER, type PaneRect } from './layout-tree'
 
@@ -9,7 +9,7 @@ export interface TerminalBounds {
   rows: number
 }
 
-export function getSnapshotTrees(snapshot: WorkspaceSnapshotV1 | undefined): LayoutNode[] {
+export function getSnapshotTrees(snapshot: ProjectSnapshotV1 | undefined): LayoutNode[] {
   if (snapshot?.layoutTrees) {
     return Object.values(snapshot.layoutTrees)
   }

package/src/state/project-catalog.ts

@@ -0,0 +1,275 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import type { ProjectRecord } from './types'
+
+import { loadConfig, saveConfig } from '../config'
+import { logDebug } from '../debug/input-log'
+import { getProfileConfigDir } from '../profile-paths'
+import { ensureProjectWorkspaces } from './project-workspaces'
+import { toast } from './toast-store'
+import { isProjectRecord } from './validation'
+
+const CATALOG_VERSION = 2
+
+interface ProjectCatalogFile {
+  version: typeof CATALOG_VERSION
+  projects: ProjectRecord[]
+}
+
+// Resolved per call, never module-cached: $HOME is read at call time so tests
+// that redirect it cannot clobber the real catalog.
+function projectsPath(): string {
+  return join(getProfileConfigDir(), 'aimux-projects.json')
+}
+
+// ponytail: the v1 file is left on disk so a downgrade still works. Drop this
+// helper, migrateV1 and the fallback branch a release or two out.
+function legacySessionsPath(): string {
+  return join(getProfileConfigDir(), 'aimux-sessions.json')
+}
+
+/** The v1 shape, before project/workspace naming. Only what migrateV1 reads. */
+interface LegacyProjectRecordV1 {
+  projectPath?: string
+  workspaceSnapshot?: {
+    tabs?: { worktreeId?: string }[]
+    lastActiveTabByWorktree?: Record<string, string>
+  }
+  worktrees?: { source?: string; repoRoot?: string }[]
+  activeWorktreeId?: string
+}
+
+/**
+ * v1 -> v2: `worktrees` became `workspaces`, `workspaceSnapshot` became
+ * `projectSnapshot`, and each tab's `worktreeId` became `workspaceId`. Record
+ * ids are deliberately left alone — they are opaque and may be scripted.
+ *
+ * `projectPath` is also healed here: v1 rewrote it with the *active worktree's*
+ * path, so it usually pointed inside the worktree root rather than at the repo.
+ */
+function migrateV1(records: LegacyProjectRecordV1[]): unknown[] {
+  return records.map((record) => {
+    const { activeWorktreeId, workspaceSnapshot, worktrees, ...rest } = record
+    const primaryRepoRoot = worktrees?.find((w) => w.source === 'primary')?.repoRoot
+    return {
+      ...rest,
+      ...(primaryRepoRoot != null && primaryRepoRoot !== ''
+        ? { projectPath: primaryRepoRoot }
+        : null),
+      ...(worktrees ? { workspaces: worktrees } : null),
+      ...(activeWorktreeId != null ? { activeWorkspaceId: activeWorktreeId } : null),
+      ...(workspaceSnapshot
+        ? {
+            projectSnapshot: (() => {
+              const { lastActiveTabByWorktree, tabs, ...snapshot } = workspaceSnapshot
+              return {
+                ...snapshot,
+                ...(lastActiveTabByWorktree
+                  ? { lastActiveTabByWorkspace: lastActiveTabByWorktree }
+                  : null),
+                ...(tabs
+                  ? {
+                      tabs: tabs.map(({ worktreeId, ...tab }) => ({
+                        ...tab,
+                        ...(worktreeId != null ? { workspaceId: worktreeId } : null),
+                      })),
+                    }
+                  : null),
+              }
+            })(),
+          }
+        : null),
+    }
+  })
+}
+
+/**
+ * Copy the catalog aside before the load path writes over it. Called whenever
+ * we could not read the file whole: the app is about to persist its own
+ * reduced view, and without this that write is the point of no return.
+ */
+function backupUnreadableCatalog(): void {
+  const source = projectsPath()
+  if (!existsSync(source)) return
+  const target = `${source}.unreadable`
+  try {
+    copyFileSync(source, target)
+    logDebug('projects.catalog.backup', { target })
+  } catch (error) {
+    logDebug('projects.catalog.backupFailed', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+function parseCatalog(path: string, version: number): { projects: unknown[] } | { issue: string } {
+  const parsed = JSON.parse(readFileSync(path, 'utf8')) as {
+    version?: unknown
+    projects?: unknown
+    sessions?: unknown
+  }
+  if (parsed.version !== version) {
+    return { issue: `invalid project catalog header in ${path}` }
+  }
+  // v1 called the array `sessions`.
+  const records = parsed.projects ?? parsed.sessions
+  if (!Array.isArray(records)) {
+    return { issue: `invalid project catalog header in ${path}` }
+  }
+  return { projects: records }
+}
+
+function readCatalogFile(): { file: ProjectCatalogFile | null; issue?: string } {
+  try {
+    let records: unknown[]
+    if (existsSync(projectsPath())) {
+      const parsed = parseCatalog(projectsPath(), CATALOG_VERSION)
+      if ('issue' in parsed) {
+        backupUnreadableCatalog()
+        return { file: null, issue: parsed.issue }
+      }
+      records = parsed.projects
+    } else if (existsSync(legacySessionsPath())) {
+      const parsed = parseCatalog(legacySessionsPath(), 1)
+      if ('issue' in parsed) return { file: null, issue: parsed.issue }
+      records = migrateV1(parsed.projects as LegacyProjectRecordV1[])
+      logDebug('projects.catalog.migrateV1', { projectCount: records.length })
+    } else {
+      return { file: null }
+    }
+
+    // Keep the records that survive validation instead of failing the whole
+    // file: one malformed entry used to cost the user every project, and since
+    // the load path writes back what it loaded, that loss became permanent on
+    // the next save. Whatever we could not read is preserved by the backup
+    // below, so nothing is destroyed either way.
+    const valid = records.filter(isProjectRecord)
+    if (valid.length !== records.length) {
+      backupUnreadableCatalog()
+      return {
+        file: { projects: valid, version: CATALOG_VERSION },
+        issue: `${records.length - valid.length} unreadable project record(s) skipped`,
+      }
+    }
+
+    return { file: { projects: valid, version: CATALOG_VERSION } }
+  } catch (error) {
+    backupUnreadableCatalog()
+    return {
+      file: null,
+      issue: `failed to load project catalog: ${error instanceof Error ? error.message : String(error)}`,
+    }
+  }
+}
+
+export function loadProjectCatalog(): ProjectRecord[] {
+  const { file, issue } = readCatalogFile()
+  if (file) {
+    logDebug('projects.catalog.load', { projectCount: file.projects.length })
+    if (issue != null && issue !== '') {
+      // Same reasoning as the save path below: losing projects is not something
+      // the user should have to read a debug log to discover.
+      toast.error(`${issue} — original kept at ${projectsPath()}.unreadable`)
+    }
+    const normalized = normalizeProjects(file.projects)
+    // A fresh migration has no v2 file yet, so write even when normalizing
+    // changed nothing.
+    if (
+      !existsSync(projectsPath()) ||
+      JSON.stringify(normalized) !== JSON.stringify(file.projects)
+    ) {
+      saveProjectCatalog(normalized)
+    }
+    return normalized
+  }
+
+  if (issue != null && issue !== '') {
+    logDebug('projects.catalog.loadIssue', { issue, path: projectsPath() })
+  }
+
+  const config = loadConfig()
+  if (!config.projectSnapshot) {
+    logDebug('projects.catalog.load', { projectCount: 0 })
+    return []
+  }
+
+  const now = new Date().toISOString()
+  const migrated: ProjectRecord = {
+    createdAt: now,
+    id: `project-${Date.now()}`,
+    lastOpenedAt: now,
+    name: 'Last project',
+    projectSnapshot: config.projectSnapshot,
+    updatedAt: now,
+  }
+
+  const normalized = normalizeProjects([migrated])
+  saveProjectCatalog(normalized)
+  saveConfig({ ...config, projectSnapshot: undefined })
+  logDebug('projects.catalog.migrateLegacyProject', {
+    migratedProjectId: migrated.id,
+    tabCount: migrated.projectSnapshot?.tabs.length ?? 0,
+  })
+  return normalized
+}
+
+export function saveProjectCatalog(projects: ProjectRecord[]): void {
+  try {
+    mkdirSync(getProfileConfigDir(), { recursive: true })
+    writeFileSync(
+      projectsPath(),
+      `${JSON.stringify({ projects, version: CATALOG_VERSION }, null, 2)}\n`
+    )
+    logDebug('projects.catalog.save', { projectCount: projects.length })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    logDebug('projects.catalog.saveError', {
+      error: message,
+      path: projectsPath(),
+      projectCount: projects.length,
+    })
+    // Persisting the catalog underpins project/workspace state — a silent
+    // failure means the user loses projects on restart. Surface it.
+    toast.error(`Failed to save projects: ${message}`)
+  }
+}
+
+export function getProjectCatalogPath(): string {
+  return projectsPath()
+}
+
+export function findMostRecentProject(projects: ProjectRecord[]): ProjectRecord | undefined {
+  let best: ProjectRecord | undefined
+  for (const candidate of projects) {
+    if (!best || candidate.lastOpenedAt.localeCompare(best.lastOpenedAt) > 0) {
+      best = candidate
+    }
+  }
+  return best
+}
+
+/**
+ * Assign a stable `order` to every project. Records with an existing numeric
+ * `order` keep their slot (sorted ascending); the rest are appended by
+ * createdAt ascending so older projects come first.
+ */
+function normalizeOrder(projects: ProjectRecord[]): ProjectRecord[] {
+  const withOrder: ProjectRecord[] = []
+  const withoutOrder: ProjectRecord[] = []
+  for (const s of projects) {
+    if (typeof s.order === 'number' && Number.isFinite(s.order)) {
+      withOrder.push(s)
+    } else {
+      withoutOrder.push(s)
+    }
+  }
+  withOrder.sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+  withoutOrder.sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+  const merged = [...withOrder, ...withoutOrder]
+  return merged.map((s, i) => (s.order === i ? s : { ...s, order: i }))
+}
+
+function normalizeProjects(projects: ProjectRecord[]): ProjectRecord[] {
+  return normalizeOrder(projects).map((project) => ensureProjectWorkspaces(project))
+}