@cat-factory/app 0.315.4 → 0.315.6

package/app/components/bootstrap/BootstrapModal.vue

@@ -54,7 +54,7 @@ watch(
 async function loadGitHubRepos() {
   try {
     await github.probe()
-    if (github.connected) await github.load()
+    await github.refresh()
   } catch {
     // GitHub integration off / unreachable → the repo picker just isn't offered.
   }

package/app/components/github/AddServiceFromRepoModal.vue

@@ -59,10 +59,10 @@ const adding = ref(false)
 async function loadRepos() {
   try {
     await github.probe()
-    // Load only the linked-repo projection (to flag repos already on the board). The
+    // Load the linked-repo projection once per board (to flag repos already on the board). The
     // available-repos list is NOT prefetched — it's searched server-side on demand once
     // the user types (see the repoQueryRaw watcher), so a wide install isn't shipped whole.
-    if (github.connected) await github.load()
+    await github.refresh()
   } catch {
     // Integration off / unreachable → the picker stays empty, GitHubConnect shows.
   }

package/app/components/github/GitHubPanel.vue

@@ -100,7 +100,7 @@ watch(
   open,
   (isOpen) => {
     if (!isOpen) return
-    if (github.connected) void github.load()
+    if (github.connected) void github.refresh()
   },
   { immediate: true },
 )

package/app/components/panels/InspectorPanel.vue

@@ -24,10 +24,15 @@ const recurring = useRecurringPipelinesStore()
 const requirements = useRequirementsStore()
 const access = useWorkspaceAccess()
 const { t } = useI18n()
+const { present } = usePipelineErrorToast()
 
 onMounted(() => {
   fragments.ensureLoaded()
-  github.ensureLoaded()
+  // The repo list behind the inspector's repo link and the service config's detect-from-repo
+  // lookup. Both read the store, so this one call serves them.
+  github.ensureLoaded().catch((error: unknown) => {
+    present(error, 'github.connect.errors.loadProjection')
+  })
 })
 
 const block = computed<Block | undefined>(() =>

package/app/components/panels/inspector/ServiceTestConfig.vue

@@ -50,10 +50,10 @@ const ui = useUiStore()
 const { t, te } = useI18n()
 
 // The custom-manifest-type catalog feeds the `custom` picker. Cheap + shared (coalesced).
-// The repo list backs the detect-from-repo affordance (owner/name lookup).
+// The repo list behind the detect-from-repo affordance (owner/name lookup) is loaded by the
+// surface that hosts this section: the inspector panel, or the add-service modal on open.
 onMounted(() => {
   void infra.ensureLoaded()
-  void github.ensureLoaded()
 })
 
 // The service's declared provision type (absent ⇒ treated as `infraless`: no environment

package/app/components/pipeline/PipelineBuilder.vue

@@ -252,6 +252,8 @@ const open = computed({
 // knows whether to offer the post-release-health gate (it's loaded on demand, not from
 // the snapshot). Best-effort: a failure just leaves the gate hidden.
 onModalOpen(open, () => {
+  // Coming back from the model configuration, where none of this changed.
+  if (ui.consumeBuilderReturn()) return
   releaseHealth.load().catch(() => {})
   // The prompt-override index badges the steps whose agent no longer runs the shipped prompt.
   // Best-effort: the builder is fully usable without it, and a deployment that wires no
@@ -404,6 +406,7 @@ const { toggleArchive, toggleDefault, edit, removePipeline, clone } = usePipelin
     :title="t('pipeline.builder.title')"
     side="left"
     :ui="{ content: 'max-w-[90vw] sm:max-w-2xl lg:max-w-5xl xl:max-w-6xl' }"
+    @after:leave="ui.builderLeft()"
   >
     <template #body>
       <!-- On compact viewports the three sections stack and the slideover body
@@ -443,6 +446,7 @@ const { toggleArchive, toggleDefault, edit, removePipeline, clone } = usePipelin
               size="xs"
               icon="i-lucide-cpu"
               :title="t('pipeline.builder.configureModelsTooltip')"
+              data-testid="pipeline-builder-configure-models"
               @click="ui.openModelConfig()"
             >
               {{ t('pipeline.builder.configureModels') }}

package/app/components/settings/ModelConfigurationPanel.vue

@@ -311,6 +311,7 @@ async function save() {
     <Transition name="reader-fade">
       <div
         v-if="open"
+        data-testid="model-configuration-panel"
         class="z-50 flex-col bg-app-950/96 backdrop-blur-sm"
         :class="FULL_BLEED_TAKEOVER_CLASS"
         role="dialog"
@@ -377,7 +378,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>
@@ -491,6 +498,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"

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])
+  })
+})

package/app/stores/github.ts

@@ -20,6 +20,7 @@ import { useServicesStore } from '~/stores/services'
 import { pullKey, type GitHubStoreContext } from '~/stores/github/context'
 import { createGitHubConnectionActions } from '~/stores/github/connection'
 import { createGitHubProbe } from '~/stores/github/probe'
+import { createGitHubProjectionLoad } from '~/stores/github/projectionLoad'
 import { createGitHubRepoActions } from '~/stores/github/repoActions'
 import { createVcsConnectActions, createVcsProviderViews } from '~/stores/github/vcsConnect'
 
@@ -138,23 +139,20 @@ export const useGitHubStore = defineStore('github', () => {
     return branchWebUrl(providerOfRepo(repoGithubId), repoUrl(repoGithubId), branch)
   }
 
-  /** Load the cached repos, pull requests and issues for the workspace. */
-  async function load() {
-    if (!connected.value) return
-    loading.value = true
-    try {
-      const [r, p, i] = await Promise.all([
-        api.listGitHubRepos(workspace.requireId()),
-        api.listGitHubPullRequests(workspace.requireId()),
-        api.listGitHubIssues(workspace.requireId()),
-      ])
-      repos.value = r
-      pulls.value = p
-      issues.value = i
-    } finally {
-      loading.value = false
-    }
-  }
+  // The projection read and the record of whether it is loaded for this workspace.
+  const projection = createGitHubProjectionLoad({
+    api,
+    workspace,
+    connection,
+    repos,
+    pulls,
+    issues,
+    loading,
+  })
+  /** Reload the cached repos, pull requests and issues after a write. */
+  const load = projection.load
+  /** Reload them on demand, sharing a read already in flight. */
+  const refresh = projection.refresh
 
   /** Full file listing per repo (recursive tree), cached by GitHub numeric id. */
   const repoFiles = ref<Record<number, RepoTreeEntry[]>>({})
@@ -184,6 +182,8 @@ export const useGitHubStore = defineStore('github', () => {
     syncing,
     connected,
     load,
+    markWritten: projection.markWritten,
+    clearProjection: projection.clearProjection,
   }
   // The board-load probe (integration availability + the bound connection + the connect options +
   // the credential check). Built from the context rather than inline, so this setup stays within
@@ -193,11 +193,11 @@ export const useGitHubStore = defineStore('github', () => {
   /**
    * Ensure the projection (repos/PRs/issues) is loaded at least once — for views
    * that need it without opening the GitHub panel (e.g. the inspector's repo link).
-   * Probes the integration first if it hasn't been yet.
+   * Probes the integration first if it hasn't been yet. Concurrent callers share one read.
    */
   async function ensureLoaded() {
     if (available.value === null) await probe()
-    if (connected.value && repos.value.length === 0) await load()
+    await projection.ensureLoaded()
   }
 
   const connectionActions = createGitHubConnectionActions(context)
@@ -213,16 +213,14 @@ export const useGitHubStore = defineStore('github', () => {
    * land. `available` returns to `null` (unknown) so the onboarding gate re-resolves.
    */
   function reset() {
+    projection.clearProjection()
     available.value = null
     unavailableCause.value = null
     connection.value = null
     connectOptions.value = []
     patCheck.value = null
     installations.value = []
-    repos.value = []
     availableRepos.value = []
-    pulls.value = []
-    issues.value = []
     branches.value = {}
     repoFiles.value = {}
   }
@@ -259,6 +257,7 @@ export const useGitHubStore = defineStore('github', () => {
     probe,
     ensureProbed,
     load,
+    refresh,
     ensureLoaded,
     repoFiles,
     ...connectionActions,

package/app/stores/ui/builderModelConfigHandoff.spec.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect } from 'vitest'
+import { createUiModals } from '~/stores/ui/modals'
+
+/**
+ * The pipeline builder and the model configuration never stack. The builder is a modal Reka
+ * slideover that holds `pointer-events: none` on <body> until its exit animation ends, so the
+ * model configuration (the app's own takeover) only shows once the builder reports it has left.
+ */
+describe('pipeline builder to model configuration handoff', () => {
+  it('shows the model configuration only after the builder has left, and reopens the builder on close', () => {
+    const ui = createUiModals()
+    ui.openBuilder()
+
+    ui.openModelConfig()
+    expect(ui.builderOpen.value).toBe(false)
+    expect(ui.modelConfigOpen.value).toBe(false)
+
+    ui.builderLeft()
+    expect(ui.modelConfigOpen.value).toBe(true)
+
+    ui.closeModelConfig()
+    expect(ui.modelConfigOpen.value).toBe(false)
+    expect(ui.builderOpen.value).toBe(true)
+  })
+
+  it('opens at once when the builder is not open, and ignores a stray builder exit', () => {
+    const ui = createUiModals()
+    ui.openModelConfig()
+    expect(ui.modelConfigOpen.value).toBe(true)
+
+    ui.closeModelConfig()
+    expect(ui.builderOpen.value).toBe(false)
+
+    ui.builderLeft()
+    expect(ui.modelConfigOpen.value).toBe(false)
+  })
+
+  it('returns to the builder once, not on every later close', () => {
+    const ui = createUiModals()
+    ui.openBuilder()
+    ui.openModelConfig()
+    ui.builderLeft()
+    ui.closeModelConfig()
+    ui.builderOpen.value = false
+
+    ui.openModelConfig()
+    ui.closeModelConfig()
+    expect(ui.builderOpen.value).toBe(false)
+  })
+
+  it('opening the builder another way closes the model configuration and drops the return', () => {
+    const ui = createUiModals()
+    ui.openBuilder()
+    ui.openModelConfig()
+    ui.builderLeft()
+
+    ui.openBuilder()
+    expect(ui.modelConfigOpen.value).toBe(false)
+    expect(ui.builderOpen.value).toBe(true)
+
+    ui.builderOpen.value = false
+    ui.openModelConfig()
+    ui.closeModelConfig()
+    expect(ui.builderOpen.value).toBe(false)
+  })
+
+  it('drops a pending show when the builder is reopened before it has left', () => {
+    const ui = createUiModals()
+    ui.openBuilder()
+    ui.openModelConfig()
+    ui.openBuilder()
+
+    ui.builderLeft()
+    expect(ui.modelConfigOpen.value).toBe(false)
+  })
+
+  it('reports a return to the builder once, so it can skip its reloads', () => {
+    const ui = createUiModals()
+    ui.openBuilder()
+    expect(ui.consumeBuilderReturn()).toBe(false)
+
+    ui.openModelConfig()
+    ui.builderLeft()
+    ui.closeModelConfig()
+    expect(ui.consumeBuilderReturn()).toBe(true)
+    expect(ui.consumeBuilderReturn()).toBe(false)
+  })
+})

package/app/stores/ui/modals.ts

@@ -182,6 +182,80 @@ function createHealthAdvisoryModals() {
   }
 }
 
+/**
+ * The pipeline builder and the model configuration never stack. Opening the model configuration
+ * from the builder closes the builder, shows the model configuration once the builder has
+ * finished leaving, and brings the builder back when the model configuration closes.
+ *
+ * The builder is a `USlideover`, a modal Reka layer: while it is mounted, Reka sets
+ * `pointer-events: none` on `<body>`, and lifts it only when the exit animation ends. The model
+ * configuration is the app's own takeover, teleported to `<body>` and not a Reka layer, so shown
+ * over the builder (or during its exit) every click landed on the builder behind it. Waiting for
+ * the exit (`builderLeft`, from the builder's `after:leave`) fixes that without an escape hatch on
+ * the panel, which would also defeat the pointer lock of the panel's OWN dropdowns. The fix lives
+ * here, not at the builder's "Configure models" button, because the "choose a model" action on a
+ * run-admission failure toast (`preset_unsatisfiable`, `model_policy_blocked`) also opens the
+ * model configuration.
+ *
+ * This owns BOTH openers: `openBuilder` closes the model configuration and drops a pending return,
+ * so a builder the user opened another way is not followed by a stale reopen.
+ *
+ * Closing the builder unmounts its body. The draft pipeline is in the pipelines store and survives,
+ * but component-local state does not: a half-typed output size in the binary-output picker, the
+ * rejected media types and references it reports, and the guarded-gate roster. The builder
+ * reloads nothing on the way back (`consumeBuilderReturn`), since nothing it loads changes while
+ * the model configuration is open.
+ *
+ * Other takeovers (reports, kaizen, operator dashboard) opened over a modal Reka layer have the
+ * same unclickable-takeover defect and are not handled here.
+ */
+function createBuilderModelConfigHandoff(
+  misc: Pick<ReturnType<typeof createMiscModals>, 'builderOpen'>,
+  panels: Pick<ReturnType<typeof createIntegrationPanelModals>, 'modelConfigOpen'>,
+) {
+  const returnToBuilder = ref(false)
+  const showAfterBuilderExit = ref(false)
+  const returningToBuilder = ref(false)
+
+  function openModelConfig() {
+    if (showAfterBuilderExit.value) return
+    if (misc.builderOpen.value) {
+      misc.builderOpen.value = false
+      returnToBuilder.value = true
+      showAfterBuilderExit.value = true
+      return
+    }
+    panels.modelConfigOpen.value = true
+  }
+  function builderLeft() {
+    if (!showAfterBuilderExit.value) return
+    showAfterBuilderExit.value = false
+    panels.modelConfigOpen.value = true
+  }
+  function closeModelConfig() {
+    panels.modelConfigOpen.value = false
+    if (!returnToBuilder.value) return
+    returnToBuilder.value = false
+    returningToBuilder.value = true
+    misc.builderOpen.value = true
+  }
+  function openBuilder() {
+    panels.modelConfigOpen.value = false
+    showAfterBuilderExit.value = false
+    returnToBuilder.value = false
+    returningToBuilder.value = false
+    misc.builderOpen.value = true
+  }
+  /** True once per return from the model configuration, so the builder can skip its reloads. */
+  function consumeBuilderReturn(): boolean {
+    const returning = returningToBuilder.value
+    returningToBuilder.value = false
+    return returning
+  }
+
+  return { openModelConfig, closeModelConfig, openBuilder, builderLeft, consumeBuilderReturn }
+}
+
 /**
  * Small standalone surfaces with no hub relationship: the pipeline builder and the
  * decision-wait window.
@@ -190,9 +264,6 @@ function createMiscModals() {
   const builderOpen = ref(false)
   const decisionContext = ref<{ instanceId: string; decisionId: string } | null>(null)
 
-  function openBuilder() {
-    builderOpen.value = true
-  }
   function openDecision(instanceId: string, decisionId: string) {
     decisionContext.value = { instanceId, decisionId }
   }
@@ -200,7 +271,7 @@ function createMiscModals() {
     decisionContext.value = null
   }
 
-  return { builderOpen, decisionContext, openBuilder, openDecision, closeDecision }
+  return { builderOpen, decisionContext, openDecision, closeDecision }
 }
 
 /** What the guided review window opens on: a session, a pull request, or neither (the picker). */
@@ -590,6 +661,7 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
   // API access tokens: the workspace's inbound public-API keys external systems present to
   // the `/api/v1` surface. Opened from the Integrations hub.
   const apiTokensOpen = ref(false)
+  // Opened and closed by `createBuilderModelConfigHandoff`, which hands the pipeline builder over.
   const modelConfigOpen = ref(false)
   // LLM-vendor subscription credentials (the token pool powering the Claude Code
   // / Codex harnesses). `vendorCredentialsTab` lets a caller deep-link to one tab —
@@ -651,12 +723,6 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
   function closeApiTokens() {
     apiTokensOpen.value = false
   }
-  function openModelConfig() {
-    modelConfigOpen.value = true
-  }
-  function closeModelConfig() {
-    modelConfigOpen.value = false
-  }
   function openVendorCredentials(tab = 'pool') {
     resetHubReturn()
     vendorCredentialsTab.value = tab
@@ -718,8 +784,6 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
     closeOperatorDashboard,
     openApiTokens,
     closeApiTokens,
-    openModelConfig,
-    closeModelConfig,
     openVendorCredentials,
     setVendorCredentialsTab,
     closeVendorCredentials,
@@ -1223,6 +1287,7 @@ export function createUiModals() {
   const settings = createSettingsModals(resetHubReturn)
   const infra = createInfraModals(resetHubReturn)
   const ai = createAiOnboardingModals()
+  const builderHandoff = createBuilderModelConfigHandoff(misc, panels)
 
   return {
     integrationsOpen,
@@ -1249,5 +1314,6 @@ export function createUiModals() {
     ...settings,
     ...infra,
     ...ai,
+    ...builderHandoff,
   }
 }

package/i18n/locales/de.json

@@ -3712,6 +3712,7 @@
       },
       "errors": {
         "listInstallations": "GitHub-Installationen konnten nicht aufgelistet werden",
+        "loadProjection": "Repositories, Pull Requests und Issues konnten nicht geladen werden",
         "startInstall": "Die Installation der GitHub App konnte nicht gestartet werden",
         "connect": "Verbindung nicht möglich"
       }

package/i18n/locales/en.json

@@ -4720,6 +4720,7 @@
       },
       "errors": {
         "listInstallations": "Could not list GitHub installations",
+        "loadProjection": "Could not load repositories, pull requests and issues",
         "startInstall": "Could not start the GitHub App install",
         "connect": "Could not connect"
       }

package/i18n/locales/es.json

@@ -4544,6 +4544,7 @@
       },
       "errors": {
         "listInstallations": "No se pudieron listar las instalaciones de GitHub",
+        "loadProjection": "No se pudieron cargar los repositorios, las pull requests y las issues",
         "startInstall": "No se pudo iniciar la instalación de la GitHub App",
         "connect": "No se pudo conectar"
       }

package/i18n/locales/fr.json

@@ -4544,6 +4544,7 @@
       },
       "errors": {
         "listInstallations": "Impossible de lister les installations GitHub",
+        "loadProjection": "Impossible de charger les dépôts, les pull requests et les issues",
         "startInstall": "Impossible de démarrer l'installation de la GitHub App",
         "connect": "Connexion impossible"
       }

package/i18n/locales/he.json

@@ -4544,6 +4544,7 @@
       },
       "errors": {
         "listInstallations": "לא ניתן היה לרשום את התקנות GitHub",
+        "loadProjection": "לא ניתן היה לטעון מאגרים, בקשות משיכה ובעיות",
         "startInstall": "לא ניתן היה להתחיל את התקנת אפליקציית GitHub",
         "connect": "לא ניתן היה להתחבר"
       }

package/i18n/locales/it.json

@@ -3712,6 +3712,7 @@
       },
       "errors": {
         "listInstallations": "Impossibile elencare le installazioni GitHub",
+        "loadProjection": "Impossibile caricare repository, pull request e issue",
         "startInstall": "Impossibile avviare l'installazione della GitHub App",
         "connect": "Impossibile collegare"
       }

package/i18n/locales/ja.json

@@ -4544,6 +4544,7 @@
       },
       "errors": {
         "listInstallations": "GitHub のインストール一覧を取得できませんでした",
+        "loadProjection": "リポジトリ、プルリクエスト、イシューを読み込めませんでした",
         "startInstall": "GitHub App のインストールを開始できませんでした",
         "connect": "接続できませんでした"
       }

package/i18n/locales/pl.json

@@ -4544,6 +4544,7 @@
       },
       "errors": {
         "listInstallations": "Nie udało się wyświetlić instalacji GitHub",
+        "loadProjection": "Nie udało się wczytać repozytoriów, pull requestów i zgłoszeń",
         "startInstall": "Nie udało się rozpocząć instalacji aplikacji GitHub",
         "connect": "Nie udało się połączyć"
       }

package/i18n/locales/tr.json

@@ -4544,6 +4544,7 @@
       },
       "errors": {
         "listInstallations": "GitHub yüklemeleri listelenemedi",
+        "loadProjection": "Depolar, çekme istekleri ve sorunlar yüklenemedi",
         "startInstall": "GitHub App yüklemesi başlatılamadı",
         "connect": "Bağlanamadı"
       }

package/i18n/locales/uk.json

@@ -4544,6 +4544,7 @@
       },
       "errors": {
         "listInstallations": "Не вдалося отримати список встановлень GitHub",
+        "loadProjection": "Не вдалося завантажити репозиторії, pull request-и та issue",
         "startInstall": "Не вдалося розпочати встановлення застосунку GitHub",
         "connect": "Не вдалося підключити"
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.315.4",
+  "version": "0.315.6",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",