@cat-factory/app 0.315.4 → 0.315.7

package/app/components/settings/ModelConfigurationPanel.vue

@@ -11,7 +11,6 @@
 // preference. The list view shows each preset; the editor view creates/edits one with a
 // base-model picker plus a filterable per-agent override list.
 import { computed, ref, watch } from 'vue'
-import { onKeyStroke } from '@vueuse/core'
 import type { ModelFlavor } from '@cat-factory/contracts'
 import type { AgentKind } from '~/types/domain'
 import type { ModelPreset } from '~/types/model-presets'
@@ -25,7 +24,7 @@ import { showOverrideField } from '~/utils/uiMode'
 import SectionLabel from '~/components/common/SectionLabel.vue'
 import IconButton from '~/components/common/IconButton.vue'
 import EmptyState from '~/components/common/EmptyState.vue'
-import { FULL_BLEED_TAKEOVER_CLASS } from '~/utils/safeArea'
+import TakeoverShell from '~/components/common/TakeoverShell.vue'
 
 const { t } = useI18n()
 const ui = useUiStore()
@@ -119,12 +118,11 @@ watch(
   { immediate: true },
 )
 
-onKeyStroke('Escape', () => {
-  if (!open.value) return
-  // Esc backs out of the editor first, then closes the panel.
+// Esc backs out of the editor first, then closes the panel.
+function backOut() {
   if (editor.value) editor.value = null
   else open.value = false
-})
+}
 
 /** The selectable catalog models, as `{ id, label, suffix }` for a dropdown. */
 const selectableModels = computed(() => {
@@ -309,12 +307,13 @@ async function save() {
 <template>
   <Teleport to="body">
     <Transition name="reader-fade">
-      <div
+      <TakeoverShell
         v-if="open"
-        class="z-50 flex-col bg-app-950/96 backdrop-blur-sm"
-        :class="FULL_BLEED_TAKEOVER_CLASS"
-        role="dialog"
-        aria-modal="true"
+        :label="t('settings.modelConfiguration.title')"
+        :content-key="editor ? 'editor' : 'list'"
+        class="flex-col bg-app-950/96 backdrop-blur-sm"
+        data-testid="model-configuration-panel"
+        @close="backOut"
       >
         <header class="flex items-center gap-3 border-b border-default px-6 py-4">
           <div class="flex h-9 w-9 shrink-0 items-center justify-center rounded-lg bg-primary/15">
@@ -377,7 +376,13 @@ async function save() {
                     </template>
                   </i18n-t>
                 </p>
-                <UButton icon="i-lucide-plus" size="sm" class="shrink-0" @click="startCreate">
+                <UButton
+                  icon="i-lucide-plus"
+                  size="sm"
+                  class="shrink-0"
+                  data-testid="model-preset-new"
+                  @click="startCreate"
+                >
                   {{ t('settings.modelConfiguration.list.newPreset') }}
                 </UButton>
               </div>
@@ -437,6 +442,7 @@ async function save() {
                         variant="ghost"
                         color="error"
                         icon="i-lucide-trash-2"
+                        data-testid="model-preset-delete"
                         :disabled="p.isDefault"
                         :loading="busy"
                         :label="
@@ -491,6 +497,7 @@ async function save() {
                   </SectionLabel>
                   <UInput
                     v-model="editor.name"
+                    data-testid="model-preset-name"
                     :placeholder="t('settings.modelConfiguration.editor.namePlaceholder')"
                     size="sm"
                     class="w-full"
@@ -510,6 +517,7 @@ async function save() {
                       variant="subtle"
                       trailing-icon="i-lucide-chevron-down"
                       class="w-full justify-between"
+                      data-testid="model-preset-base-model"
                     >
                       <span class="truncate">{{ modelLabel(editor.baseModelId) }}</span>
                     </UButton>
@@ -610,7 +618,7 @@ async function save() {
             </template>
           </div>
         </div>
-      </div>
+      </TakeoverShell>
     </Transition>
   </Teleport>
 </template>

package/app/plugins/foreign-layers.client.ts

@@ -0,0 +1,8 @@
+import { sharedOverlayStack } from '@modular-vue/core'
+import { trackForeignLayers } from '~/utils/foreignLayers'
+
+// Put every open Nuxt UI menu, select, popover and modal on the shared overlay stack, so the
+// takeover or window under it leaves Escape and Tab to it. Why: `utils/foreignLayers.ts`.
+export default defineNuxtPlugin(() => {
+  trackForeignLayers(document.body, sharedOverlayStack)
+})

package/app/stores/github/connection.ts

@@ -14,7 +14,7 @@ import type { GitHubStoreContext } from './context'
  */
 export function createGitHubConnectionActions(ctx: GitHubStoreContext) {
   const { api, workspace, available, connection, installations, loadingInstallations } = ctx
-  const { repos, availableRepos, pulls, issues, branches, syncing, load } = ctx
+  const { availableRepos, branches, syncing, load, clearProjection } = ctx
 
   /** The URL a workspace owner visits to install the App against this workspace. */
   function getInstallUrl(): Promise<string> {
@@ -48,10 +48,8 @@ export function createGitHubConnectionActions(ctx: GitHubStoreContext) {
     // Backends predating the discriminator omit `provider`; those connections are GitHub App ones.
     await DISCONNECT_BY_PROVIDER[connection.value?.provider ?? 'github'](workspace.requireId())
     connection.value = null
-    repos.value = []
+    clearProjection()
     availableRepos.value = []
-    pulls.value = []
-    issues.value = []
     branches.value = {}
   }
 

package/app/stores/github/context.ts

@@ -45,6 +45,10 @@ export interface GitHubStoreContext {
   syncing: Ref<boolean>
   /** Whether an App installation is bound (the store's `connected` computed). */
   connected: Readonly<Ref<boolean>>
-  /** Reload the cached repos/PRs/issues projection (the store's `load`). */
+  /** Reload the cached repos/PRs/issues projection after a write (the store's `load`). */
   load: () => Promise<void>
+  /** Record a direct write to the projection, so a read that started before it cannot land. */
+  markWritten: () => void
+  /** Empty the repos/PRs/issues projection and mark it unloaded, so `ensureLoaded` reads it again. */
+  clearProjection: () => void
 }

package/app/stores/github/projectionLoad.ts

@@ -0,0 +1,127 @@
+import type { Ref } from 'vue'
+import type { GitHubConnection, GitHubIssue, GitHubPullRequest, GitHubRepo } from '~/types/domain'
+import type { GitHubStoreContext } from '~/stores/github/context'
+
+/** What the projection load reads and writes. The store owns every ref. */
+interface ProjectionLoadDeps {
+  api: GitHubStoreContext['api']
+  workspace: GitHubStoreContext['workspace']
+  connection: Readonly<Ref<GitHubConnection | null>>
+  repos: Ref<GitHubRepo[]>
+  pulls: Ref<GitHubPullRequest[]>
+  issues: Ref<GitHubIssue[]>
+  loading: Ref<boolean>
+}
+
+interface ProjectionLoad {
+  /** Read the projection again after a write, never sharing a read that started before it. */
+  load: () => Promise<void>
+  /** Read the projection again, sharing a read already in flight for the same connection. */
+  refresh: () => Promise<void>
+  /** Read the projection unless it is already loaded for the current connection. */
+  ensureLoaded: () => Promise<void>
+  /** Record a direct write to the projection, so a read that started before it cannot land. */
+  markWritten: () => void
+  /** Empty the lists and forget the load in one step. */
+  clearProjection: () => void
+}
+
+interface InFlightRead {
+  key: string
+  promise: Promise<void>
+}
+
+/**
+ * The repos / pull requests / issues projection read, and the record of what it is loaded for.
+ *
+ * One generation counter answers every question about whether a read may land. A read takes the
+ * next number when it starts, and every direct write to the projection (`markWritten()`, which
+ * `clearProjection()` calls too) takes one as well. A read lands only if its number is still the
+ * latest and it was started for the connection that is current when it finishes, so a result that
+ * a newer read, a write, a disconnect or a board switch overtook is dropped.
+ *
+ * The projection counts as loaded for a key made of the workspace and the connection. A connected
+ * workspace with no linked repos is loaded: the empty list is its answer. A different workspace or
+ * a new connection is a different key, so a reinstall is read again without anyone telling this
+ * module that it happened.
+ *
+ * There are three doors. `ensureLoaded()` reads only when nothing is loaded, `refresh()` is a
+ * deliberate re-read that still shares a read in flight, and `load()` is the re-read after a write,
+ * which starts its own read so it never returns what the write replaced.
+ */
+export function createGitHubProjectionLoad(deps: ProjectionLoadDeps): ProjectionLoad {
+  const { api, workspace, connection, repos, pulls, issues, loading } = deps
+
+  let generation = 0
+  let loadedKey: string | null = null
+  let inFlight: InFlightRead | null = null
+
+  /** What the projection is read for. Null while there is nothing to read: no board or no connection. */
+  function currentKey(): string | null {
+    const conn = connection.value
+    if (!workspace.workspaceId || !conn) return null
+    return `${workspace.workspaceId}:${conn.provider}:${conn.installationId}:${conn.connectedAt}`
+  }
+
+  async function read(mine: number, key: string, askedFor: string): Promise<void> {
+    const [r, p, i] = await Promise.all([
+      api.listGitHubRepos(askedFor),
+      api.listGitHubPullRequests(askedFor),
+      api.listGitHubIssues(askedFor),
+    ])
+    if (mine !== generation || key !== currentKey()) return
+    repos.value = r
+    pulls.value = p
+    issues.value = i
+    loadedKey = key
+  }
+
+  function start(key: string): Promise<void> {
+    const mine = ++generation
+    loading.value = true
+    const entry: InFlightRead = {
+      key,
+      promise: read(mine, key, workspace.requireId()).finally(() => {
+        // Only the read that still owns the slot settles the flag. One that a write, a clear or a
+        // newer read replaced must not report the projection as settled.
+        if (inFlight === entry) {
+          inFlight = null
+          loading.value = false
+        }
+      }),
+    }
+    inFlight = entry
+    return entry.promise
+  }
+
+  function markWritten(): void {
+    generation++
+    inFlight = null
+    loading.value = false
+  }
+
+  return {
+    load: () => {
+      const key = currentKey()
+      return key ? start(key) : Promise.resolve()
+    },
+    refresh: () => {
+      const key = currentKey()
+      if (!key) return Promise.resolve()
+      return inFlight?.key === key ? inFlight.promise : start(key)
+    },
+    ensureLoaded: () => {
+      const key = currentKey()
+      if (!key || loadedKey === key) return Promise.resolve()
+      return inFlight?.key === key ? inFlight.promise : start(key)
+    },
+    markWritten,
+    clearProjection: () => {
+      markWritten()
+      loadedKey = null
+      repos.value = []
+      pulls.value = []
+      issues.value = []
+    },
+  }
+}

package/app/stores/github/repoActions.ts

@@ -16,7 +16,7 @@ import { pullKey, type GitHubStoreContext } from './context'
  */
 export function createGitHubRepoActions(ctx: GitHubStoreContext) {
   const { api, workspace, connected, repos, availableRepos, loadingAvailable, savingRepos } = ctx
-  const { branches, repoFiles, upsertPull, getPull, load } = ctx
+  const { branches, repoFiles, upsertPull, getPull, load, markWritten } = ctx
 
   /**
    * Load the repos the installation can access, with this workspace's link state.
@@ -55,6 +55,7 @@ export function createGitHubRepoActions(ctx: GitHubStoreContext) {
     savingRepos.value = true
     try {
       repos.value = await api.setGitHubLinkedRepos(workspace.requireId(), repoGithubIds)
+      markWritten()
       // Reflect the new link state in the picker and refresh PRs/issues.
       const linked = new Set(repoGithubIds)
       availableRepos.value = availableRepos.value.map((r) => ({
@@ -117,6 +118,7 @@ export function createGitHubRepoActions(ctx: GitHubStoreContext) {
   async function openPullRequest(repoGithubId: number, input: OpenPullRequestInput) {
     const pr = await api.openGitHubPullRequest(workspace.requireId(), repoGithubId, input)
     upsertPull(pr)
+    markWritten()
     return pr
   }
 
@@ -128,7 +130,10 @@ export function createGitHubRepoActions(ctx: GitHubStoreContext) {
     await api.mergeGitHubPullRequest(workspace.requireId(), repoGithubId, number, input)
     // Optimistically reflect the merge until the next sync confirms it.
     const existing = getPull(pullKey(repoGithubId, number))
-    if (existing) upsertPull({ ...existing, state: 'closed', merged: true })
+    if (existing) {
+      upsertPull({ ...existing, state: 'closed', merged: true })
+      markWritten()
+    }
   }
 
   function comment(repoGithubId: number, number: number, body: string) {

package/app/stores/github.spec.ts

@@ -1,7 +1,13 @@
 import { describe, it, expect, vi, type Mock } from 'vitest'
 import { useGitHubStore } from '~/stores/github'
 import { useWorkspaceStore } from '~/stores/workspace'
-import type { GitHubConnection, GitHubPatCheck, GitHubRepo, VcsConnectOption } from '~/types/domain'
+import type {
+  GitHubConnection,
+  GitHubPatCheck,
+  GitHubPullRequest,
+  GitHubRepo,
+  VcsConnectOption,
+} from '~/types/domain'
 
 // The VCS connect surface of the (single, GitHub-shaped) repo store: which connect methods the
 // deployment offers, the per-workspace GitLab PAT connect, and the provider-routed disconnect.
@@ -393,3 +399,351 @@ describe('github store — GitHub PAT credential check', () => {
     await vi.waitFor(() => expect(getGitHubPatCheck).toHaveBeenCalledTimes(2))
   })
 })
+
+// Two inspector panels call `ensureLoaded()` on the same frame selection. The probe is
+// single-flighted, so both callers share it, but the projection read behind it must be shared too.
+describe('github store: ensureLoaded', () => {
+  const repo: GitHubRepo = {
+    githubId: 1,
+    installationId: 42,
+    owner: 'acme',
+    name: 'api',
+    defaultBranch: 'main',
+    private: false,
+    syncedAt: 0,
+  }
+
+  it('loads the projection once when two callers ask at the same time', async () => {
+    // One linked repo, so the second caller cannot load again only because the list is empty.
+    const api = stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi.fn().mockResolvedValue([repo]),
+    })
+    const github = storeWithWorkspace()
+
+    await Promise.all([github.ensureLoaded(), github.ensureLoaded()])
+
+    expect(api.listGitHubRepos).toHaveBeenCalledTimes(1)
+    expect(api.listGitHubPullRequests).toHaveBeenCalledTimes(1)
+    expect(api.listGitHubIssues).toHaveBeenCalledTimes(1)
+  })
+
+  // A connected workspace with no linked repos counts as loaded: the empty list is its answer, so
+  // a later call does not read it again.
+  it('does not load again for a connected workspace with no repos', async () => {
+    const api = stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi.fn().mockResolvedValue([]),
+    })
+    const github = storeWithWorkspace()
+
+    await github.ensureLoaded()
+    await github.ensureLoaded()
+
+    expect(api.listGitHubRepos).toHaveBeenCalledTimes(1)
+    expect(api.listGitHubPullRequests).toHaveBeenCalledTimes(1)
+    expect(api.listGitHubIssues).toHaveBeenCalledTimes(1)
+  })
+
+  // A board switch resets the store, and a switch back lands on the same workspace id. The
+  // cleared projection must be read again, even though that id was loaded before.
+  it('loads again after a reset clears the projection', async () => {
+    const api = stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi.fn().mockResolvedValue([repo]),
+    })
+    const github = storeWithWorkspace()
+
+    await github.ensureLoaded()
+    github.reset()
+    await github.ensureLoaded()
+
+    expect(api.listGitHubRepos).toHaveBeenCalledTimes(2)
+    expect(github.repos).toEqual([repo])
+  })
+
+  it('loads again after a load that failed', async () => {
+    const api = stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi.fn().mockRejectedValueOnce(new Error('500')).mockResolvedValue([repo]),
+    })
+    const github = storeWithWorkspace()
+
+    await expect(github.ensureLoaded()).rejects.toThrow('500')
+    await github.ensureLoaded()
+
+    expect(api.listGitHubRepos).toHaveBeenCalledTimes(2)
+    expect(github.repos).toEqual([repo])
+  })
+
+  // `load()` is how every write refreshes the projection. A write that lands while an
+  // `ensureLoaded()` read is in flight must not get that older read back.
+  it('reads again on load() while an ensureLoaded() read is in flight', async () => {
+    const api = stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+    })
+    const github = storeWithWorkspace()
+    await github.probe()
+
+    const ensured = github.ensureLoaded()
+    const reloaded = github.load()
+    await Promise.all([ensured, reloaded])
+
+    expect(api.listGitHubRepos).toHaveBeenCalledTimes(2)
+  })
+
+  // A disconnect clears the projection outside a load. A probe that finds the workspace connected
+  // again (an App installed from another tab) must load it, not trust the earlier load.
+  it('loads again after a disconnect and a later probe that finds a connection', async () => {
+    const api = stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi.fn().mockResolvedValue([repo]),
+      disconnectGitHub: vi.fn().mockResolvedValue(undefined),
+    })
+    const github = storeWithWorkspace()
+
+    await github.ensureLoaded()
+    await github.disconnect()
+    await github.probe()
+    await github.ensureLoaded()
+
+    expect(api.listGitHubRepos).toHaveBeenCalledTimes(2)
+    expect(github.repos).toEqual([repo])
+  })
+
+  // The reads behind `ensureLoaded()` and a later `load()` overlap, and the older one can finish
+  // last. Its result is older than what is already shown, so it does not replace it.
+  it('keeps the newer read when an older one finishes after it', async () => {
+    let finishOlderRead: (repos: GitHubRepo[]) => void = () => {}
+    const newer: GitHubRepo = { ...repo, githubId: 2, name: 'web' }
+    stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi
+        .fn()
+        .mockReturnValueOnce(
+          new Promise<GitHubRepo[]>((resolve) => {
+            finishOlderRead = resolve
+          }),
+        )
+        .mockResolvedValueOnce([newer]),
+    })
+    const github = storeWithWorkspace()
+    await github.probe()
+
+    const ensured = github.ensureLoaded()
+    await github.load()
+    expect(github.repos).toEqual([newer])
+    // The older read is still running, but the newer one owns the flag and has finished.
+    expect(github.loading).toBe(false)
+
+    finishOlderRead([repo])
+    await ensured
+
+    expect(github.repos).toEqual([newer])
+  })
+
+  it('drops a read that finishes after a switch to another board', async () => {
+    let finishRead: (repos: GitHubRepo[]) => void = () => {}
+    stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi.fn().mockReturnValueOnce(
+        new Promise<GitHubRepo[]>((resolve) => {
+          finishRead = resolve
+        }),
+      ),
+    })
+    const github = storeWithWorkspace()
+    await github.probe()
+
+    const ensured = github.ensureLoaded()
+    useWorkspaceStore().workspaceId = 'ws-2'
+    github.reset()
+    finishRead([repo])
+    await ensured
+
+    expect(github.repos).toEqual([])
+  })
+
+  // In the usual order the older read finishes first. A newer read has started by then, so the older
+  // result is dropped, and the projection is not settled until the newer read finishes.
+  it('stays loading until the newest read finishes', async () => {
+    const finish: Array<(repos: GitHubRepo[]) => void> = []
+    const newer: GitHubRepo = { ...repo, githubId: 2, name: 'web' }
+    stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi.fn(
+        () =>
+          new Promise<GitHubRepo[]>((resolve) => {
+            finish.push(resolve)
+          }),
+      ),
+    })
+    const github = storeWithWorkspace()
+    await github.probe()
+
+    const ensured = github.ensureLoaded()
+    const reloaded = github.load()
+    finish[0]?.([repo])
+    await ensured
+
+    expect(github.repos).toEqual([])
+    expect(github.loading).toBe(true)
+
+    finish[1]?.([newer])
+    await reloaded
+
+    expect(github.repos).toEqual([newer])
+    expect(github.loading).toBe(false)
+  })
+
+  // A disconnect clears the projection in the same workspace, so the board id cannot tell the
+  // read apart. A read that started before the disconnect must not put the old rows back.
+  it('drops a read that finishes after a disconnect', async () => {
+    let finishRead: (repos: GitHubRepo[]) => void = () => {}
+    stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi.fn().mockReturnValueOnce(
+        new Promise<GitHubRepo[]>((resolve) => {
+          finishRead = resolve
+        }),
+      ),
+      disconnectGitHub: vi.fn().mockResolvedValue(undefined),
+    })
+    const github = storeWithWorkspace()
+    await github.probe()
+
+    const ensured = github.ensureLoaded()
+    await github.disconnect()
+    // Nothing is left to wait for, so no spinner stays up for a read whose result is thrown away.
+    expect(github.loading).toBe(false)
+    finishRead([repo])
+    await ensured
+
+    expect(github.repos).toEqual([])
+  })
+
+  // `load()` reads nothing while the workspace is not connected, so it must not record the
+  // projection as loaded. A later probe that finds a connection must lead to a read.
+  it('loads after a connection appears when load() ran while not connected', async () => {
+    const api = stubApi({
+      getGitHubConnection: vi
+        .fn()
+        .mockResolvedValueOnce({ connection: null })
+        .mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi.fn().mockResolvedValue([repo]),
+    })
+    const github = storeWithWorkspace()
+    await github.probe()
+
+    await github.load()
+    await github.probe()
+    await github.ensureLoaded()
+
+    expect(api.listGitHubRepos).toHaveBeenCalledTimes(1)
+    expect(github.repos).toEqual([repo])
+  })
+
+  // The App is uninstalled and installed again from another tab. The probe sees the new
+  // connection, and the earlier load belongs to the old one.
+  it('loads again when the probe finds a different connection', async () => {
+    const getGitHubConnection = vi
+      .fn()
+      .mockResolvedValueOnce({ connection: connection() })
+      .mockResolvedValueOnce({ connection: null })
+      .mockResolvedValue({ connection: connection({ installationId: 43, connectedAt: 2 }) })
+    const api = stubApi({
+      getGitHubConnection,
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi.fn().mockResolvedValue([repo]),
+    })
+    const github = storeWithWorkspace()
+
+    await github.ensureLoaded()
+    await github.probe()
+    await github.probe()
+    await github.ensureLoaded()
+
+    expect(api.listGitHubRepos).toHaveBeenCalledTimes(2)
+  })
+
+  // `refresh()` is the plain re-read for a surface opening while another read runs. It shares that
+  // read, where `load()` is the after-write door and starts its own.
+  it('shares an in-flight read on refresh() and starts a new one on load()', async () => {
+    const api = stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+    })
+    const github = storeWithWorkspace()
+    await github.probe()
+
+    await Promise.all([github.ensureLoaded(), github.refresh()])
+    expect(api.listGitHubRepos).toHaveBeenCalledTimes(1)
+
+    await Promise.all([github.ensureLoaded(), github.load()])
+    expect(api.listGitHubRepos).toHaveBeenCalledTimes(2)
+  })
+
+  // Saving the linked repos sets the projection directly. A read that started before the save
+  // must not put the earlier rows back, even if the reload that follows the save fails.
+  it('keeps the saved repos when a read that started before the save finishes afterwards', async () => {
+    let finishRead: (repos: GitHubRepo[]) => void = () => {}
+    const saved: GitHubRepo = { ...repo, githubId: 2, name: 'web' }
+    stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi
+        .fn()
+        .mockReturnValueOnce(
+          new Promise<GitHubRepo[]>((resolve) => {
+            finishRead = resolve
+          }),
+        )
+        .mockRejectedValueOnce(new Error('500')),
+      setGitHubLinkedRepos: vi.fn().mockResolvedValue([saved]),
+    })
+    const github = storeWithWorkspace()
+    await github.probe()
+
+    const ensured = github.ensureLoaded()
+    await expect(github.setLinkedRepos([2])).rejects.toThrow('500')
+    finishRead([repo])
+    await ensured
+
+    expect(github.repos).toEqual([saved])
+  })
+
+  it('keeps a pull request opened while a read was in flight', async () => {
+    let finishPulls: (pulls: GitHubPullRequest[]) => void = () => {}
+    const opened = { repoGithubId: 1, number: 7 } as GitHubPullRequest
+    stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: connection() }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubPullRequests: vi.fn().mockReturnValueOnce(
+        new Promise<GitHubPullRequest[]>((resolve) => {
+          finishPulls = resolve
+        }),
+      ),
+      openGitHubPullRequest: vi.fn().mockResolvedValue(opened),
+    })
+    const github = storeWithWorkspace()
+    await github.probe()
+
+    const ensured = github.ensureLoaded()
+    await github.openPullRequest(1, {} as never)
+    finishPulls([])
+    await ensured
+
+    expect(github.pulls).toEqual([opened])
+  })
+})