@cat-factory/app 0.315.3 → 0.315.6

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,
   }
 }