@cat-factory/app 0.182.1 → 0.184.0

package/app/components/settings/PackageRegistriesPanel.vue

@@ -3,24 +3,18 @@
 // orgs, GitHub Packages) that agent containers use to resolve private dependencies
 // on checkout. Tokens are write-only: the list renders from the redacted summary
 // (vendor + scopes + token tail) and an entry is edited by deleting + re-adding.
-// Opened from the Integrations hub.
-import { computed, reactive, ref, watch } from 'vue'
+// Renders inline inside the Infrastructure window's "Package registries" tab: what a
+// checkout installs from is part of where agent containers RUN, not an optional
+// external system the workspace links in.
+import { computed, onMounted, reactive, ref } from 'vue'
 import type { PackageRegistryVendor } from '~/types/packageRegistries'
-import IntegrationBackTitle from '~/components/layout/IntegrationBackTitle.vue'
 import SecretInput from '~/components/common/SecretInput.vue'
 
 const { t } = useI18n()
-const ui = useUiStore()
 const store = usePackageRegistriesStore()
 const toast = useToast()
 const { confirmAction, toastDone } = useConfirmAction()
 
-const open = computed({
-  get: () => ui.packageRegistriesOpen,
-  set: (v: boolean) => (v ? ui.openPackageRegistries() : ui.closePackageRegistries()),
-})
-const back = useIntegrationBack(open)
-
 // The registry vendors a workspace can connect. Fixed set — the host derives from the
 // vendor server-side, so it renders read-only here. Vendor names stay verbatim.
 const VENDORS: { value: PackageRegistryVendor; label: string; host: string }[] = [
@@ -59,18 +53,19 @@ function notifyError(title: string, e: unknown) {
   })
 }
 
-watch(
-  open,
-  async (isOpen) => {
-    if (!isOpen) return
-    try {
-      await store.ensureLoaded()
-    } catch (e) {
-      notifyError(t('settings.packageRegistries.toast.loadFailed'), e)
-    }
-  },
-  { immediate: true },
-)
+// The tab this renders in only exists once the window's probe resolved `available === true`, so
+// `ensureLoaded()` here would early-return every time and this error branch would be dead code.
+// Read the list outright instead: the window owns the PROBE (a failure there means no tab), the
+// panel owns the DATA (a failure here means the reader is looking at a list we could not fetch,
+// and must be told). It also drops the staleness `ensureLoaded` carried — reopening the tab
+// after an entry was added elsewhere used to re-render the first load's snapshot.
+onMounted(async () => {
+  try {
+    await store.load()
+  } catch (e) {
+    notifyError(t('settings.packageRegistries.toast.loadFailed'), e)
+  }
+})
 
 async function addEntry() {
   busy.value = true
@@ -111,108 +106,121 @@ async function removeEntry(entryId: string) {
 </script>
 
 <template>
-  <UModal
-    v-model:open="open"
-    :title="t('settings.packageRegistries.title')"
-    :ui="{ content: 'max-w-lg' }"
-  >
-    <template #title>
-      <IntegrationBackTitle :title="t('settings.packageRegistries.title')" @back="back" />
-    </template>
-    <template #body>
-      <div class="space-y-4" data-testid="package-registries-panel">
-        <p class="text-sm text-slate-400">
-          {{ t('settings.packageRegistries.intro') }}
-        </p>
-
-        <section
-          v-if="store.entries.length"
-          class="space-y-2 rounded-lg border border-slate-700 p-3"
-        >
-          <h3 class="text-sm font-semibold">
-            {{ t('settings.packageRegistries.list.heading') }}
-          </h3>
-          <div
-            v-for="entry in store.entries"
-            :key="entry.id"
-            class="flex items-center justify-between gap-2 rounded-md border border-slate-800 px-3 py-2"
-          >
-            <div class="min-w-0 space-y-1">
-              <div class="flex items-center gap-2">
-                <span class="text-sm font-medium">{{ vendorLabel(entry.vendor) }}</span>
-                <span class="text-[11px] text-slate-500">
-                  {{ t('settings.packageRegistries.list.tokenTail', { tail: entry.tokenTail }) }}
-                </span>
-              </div>
-              <div class="flex flex-wrap gap-1">
-                <UBadge
-                  v-for="scope in entry.scopes"
-                  :key="scope"
-                  color="neutral"
-                  variant="soft"
-                  size="sm"
-                >
-                  {{ scope }}
-                </UBadge>
-              </div>
-            </div>
-            <UButton
-              color="error"
-              variant="ghost"
-              icon="i-lucide-trash-2"
+  <div class="space-y-4" data-testid="package-registries-panel">
+    <p class="text-sm text-slate-400">
+      {{ t('settings.packageRegistries.intro') }}
+    </p>
+
+    <section v-if="store.entries.length" class="space-y-2 rounded-lg border border-slate-700 p-3">
+      <h3 class="text-sm font-semibold">
+        {{ t('settings.packageRegistries.list.heading') }}
+      </h3>
+      <div
+        v-for="entry in store.entries"
+        :key="entry.id"
+        class="flex items-center justify-between gap-2 rounded-md border border-slate-800 px-3 py-2"
+      >
+        <div class="min-w-0 space-y-1">
+          <div class="flex items-center gap-2">
+            <span class="text-sm font-medium">{{ vendorLabel(entry.vendor) }}</span>
+            <span class="text-[11px] text-slate-500">
+              {{ t('settings.packageRegistries.list.tokenTail', { tail: entry.tokenTail }) }}
+            </span>
+          </div>
+          <div class="flex flex-wrap gap-1">
+            <UBadge
+              v-for="scope in entry.scopes"
+              :key="scope"
+              color="neutral"
+              variant="soft"
               size="sm"
-              :loading="busy"
-              :data-testid="`package-registry-delete-${entry.id}`"
-              :aria-label="t('settings.packageRegistries.list.remove')"
-              @click="removeEntry(entry.id)"
-            />
+            >
+              {{ scope }}
+            </UBadge>
+            <!-- An entry with no scopes authenticates its host without routing any scope to
+                 it (the deliberate mixed public/private setup) — say so, or the row reads as
+                 half-configured. -->
+            <span v-if="!entry.scopes.length" class="text-[11px] text-slate-500">
+              {{ t('settings.packageRegistries.list.noScopes') }}
+            </span>
           </div>
-        </section>
-
-        <section class="space-y-3 rounded-lg border border-slate-700 p-3">
-          <h3 class="text-sm font-semibold">
-            {{ t('settings.packageRegistries.add.heading') }}
-          </h3>
-
-          <UFormField :label="t('settings.packageRegistries.add.vendor')">
-            <USelect
-              v-model="form.vendor"
-              :items="VENDORS"
-              value-key="value"
-              class="w-full"
-              data-testid="package-registry-vendor"
-            />
-          </UFormField>
-          <p class="text-[11px] text-slate-500">
-            {{ t('settings.packageRegistries.add.host', { host: vendorHost }) }}
-          </p>
-
-          <UFormField
-            :label="t('settings.packageRegistries.add.scopes')"
-            :help="t('settings.packageRegistries.add.scopesHelp')"
-          >
-            <UInput
-              v-model="form.scopes"
-              placeholder="@my-org, @my-other-org"
-              class="w-full"
-              data-testid="package-registry-scopes"
-            />
-          </UFormField>
-
-          <UFormField :label="t('settings.packageRegistries.add.token')">
-            <SecretInput v-model="form.token" class="w-full" data-testid="package-registry-token" />
-          </UFormField>
-
-          <UButton
-            :loading="busy"
-            :disabled="!parsedScopes.length || !form.token.trim()"
-            data-testid="package-registry-save"
-            @click="addEntry"
-          >
-            {{ t('settings.packageRegistries.add.save') }}
-          </UButton>
-        </section>
+        </div>
+        <UButton
+          color="error"
+          variant="ghost"
+          icon="i-lucide-trash-2"
+          size="sm"
+          :loading="busy"
+          :data-testid="`package-registry-delete-${entry.id}`"
+          :aria-label="t('settings.packageRegistries.list.remove')"
+          @click="removeEntry(entry.id)"
+        />
+      </div>
+    </section>
+
+    <section class="space-y-3 rounded-lg border border-slate-700 p-3">
+      <h3 class="text-sm font-semibold">
+        {{ t('settings.packageRegistries.add.heading') }}
+      </h3>
+
+      <UFormField :label="t('settings.packageRegistries.add.vendor')">
+        <USelect
+          v-model="form.vendor"
+          :items="VENDORS"
+          value-key="value"
+          class="w-full"
+          data-testid="package-registry-vendor"
+        />
+      </UFormField>
+      <p class="text-[11px] text-slate-500">
+        {{ t('settings.packageRegistries.add.host', { host: vendorHost }) }}
+      </p>
+
+      <UFormField
+        :label="t('settings.packageRegistries.add.scopes')"
+        :help="t('settings.packageRegistries.add.scopesHelp')"
+      >
+        <UInput
+          v-model="form.scopes"
+          placeholder="@my-org, @my-other-org"
+          class="w-full"
+          data-testid="package-registry-scopes"
+        />
+      </UFormField>
+      <!-- What will actually be SAVED. The parse splits on commas/whitespace and prefixes a
+           missing `@`, so the field's text and the stored scopes routinely differ — and now
+           that an empty list is a legitimate save, "I typed something that parsed to nothing"
+           and "I meant to leave this empty" would otherwise look identical at the button. -->
+      <div v-if="parsedScopes.length" class="flex flex-wrap gap-1">
+        <UBadge
+          v-for="scope in parsedScopes"
+          :key="scope"
+          color="neutral"
+          variant="soft"
+          size="sm"
+          data-testid="package-registry-parsed-scope"
+        >
+          {{ scope }}
+        </UBadge>
       </div>
-    </template>
-  </UModal>
+      <!-- Why leaving this empty is often the RIGHT answer — a scope mapping is all-or-nothing,
+           so an org publishing some of its `@org` packages publicly breaks under one. -->
+      <p class="text-[11px] text-slate-500">
+        {{ t('settings.packageRegistries.add.scopesNote') }}
+      </p>
+
+      <UFormField :label="t('settings.packageRegistries.add.token')">
+        <SecretInput v-model="form.token" class="w-full" data-testid="package-registry-token" />
+      </UFormField>
+
+      <UButton
+        :loading="busy"
+        :disabled="!form.token.trim()"
+        data-testid="package-registry-save"
+        @click="addEntry"
+      >
+        {{ t('settings.packageRegistries.add.save') }}
+      </UButton>
+    </section>
+  </div>
 </template>

package/app/composables/api/agentPrompts.ts

@@ -0,0 +1,41 @@
+import {
+  getAgentPromptContract,
+  listAgentPromptsContract,
+  promoteAgentPromptContract,
+  saveAgentPromptContract,
+} from '@cat-factory/contracts'
+import type { SaveAgentPromptInput } from '~/types/agent-prompts'
+import type { ApiContext } from './context'
+
+/**
+ * The workspace's agent system-prompt overrides, edited from the pipeline builder. There is no
+ * delete: going back to the shipped prompt is a save with `text: null`, so the history of what
+ * a workspace was running is never lost.
+ */
+export function agentPromptsApi({ send, ws }: ApiContext) {
+  return {
+    // The override INDEX (no prompt bodies) — the builder badges its steps from this.
+    listAgentPrompts: (workspaceId: string) =>
+      send(listAgentPromptsContract, { pathPrefix: ws(workspaceId) }),
+
+    // One kind's editor state: the shipped text, the effective text, and the revision log.
+    getAgentPrompt: (workspaceId: string, agentKind: string) =>
+      send(getAgentPromptContract, { pathPrefix: ws(workspaceId), pathParams: { agentKind } }),
+
+    saveAgentPrompt: (workspaceId: string, agentKind: string, body: SaveAgentPromptInput) =>
+      send(saveAgentPromptContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { agentKind },
+        body,
+      }),
+
+    // Deploy the sandbox half of the workflow: a graded prompt version becomes the live prompt.
+    // The text is read server-side from the version, so what runs is what was graded.
+    promoteAgentPrompt: (workspaceId: string, agentKind: string, sandboxPromptVersionId: string) =>
+      send(promoteAgentPromptContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { agentKind },
+        body: { sandboxPromptVersionId },
+      }),
+  }
+}

package/app/composables/useApi.ts

@@ -2,6 +2,7 @@ import type { FragmentOwnerKind } from '~/types/domain'
 import { createApiClient, createSend, createSendWith } from './api/client'
 import type { ApiContext } from './api/context'
 import { accountsApi } from './api/accounts'
+import { agentPromptsApi } from './api/agentPrompts'
 import { platformObservabilityApi } from './api/platformObservability'
 import { reportsApi } from './api/reports'
 import { authApi } from './api/auth'
@@ -134,6 +135,7 @@ export function useApi() {
     ...specApi(ctx),
     ...notificationsApi(ctx),
     ...presetsApi(ctx),
+    ...agentPromptsApi(ctx),
     ...preflightsApi(ctx),
     ...publicApiKeysApi(ctx),
     ...sharedStacksApi(ctx),

package/app/composables/usePipelineErrorToast.ts

@@ -187,6 +187,14 @@ const CONFLICT_INFO: Record<Exclude<ConflictReason, BespokeConflictReason>, Conf
     titleKey: 'errors.reviewFriction.blockedTitle',
     descriptionKey: 'errors.reviewFriction.blockedToast',
   },
+  // Reachable from this generic lookup only if a prompt save is ever driven from a run-start
+  // path; the prompt editor words it itself (it also has to re-seed its textarea from what
+  // landed). Mapped regardless — the exhaustive Record is the drift guard, not a hint that
+  // every reason arrives here.
+  prompt_revision_conflict: {
+    titleKey: 'errors.conflict.title.prompt_revision_conflict',
+    descriptionKey: 'errors.conflict.description.prompt_revision_conflict',
+  },
 }
 
 /**

package/app/pages/index.vue

@@ -437,7 +437,6 @@ watch(
       <WorkspaceSettingsPanel v-if="ui.workspaceSettingsOpen" />
       <AccountSettingsPanel v-if="ui.accountSettingsOpen" />
       <ObservabilityConnectionPanel v-if="ui.observabilityConnectionOpen" />
-      <PackageRegistriesPanel v-if="ui.packageRegistriesOpen" />
       <ApiTokensPanel v-if="ui.apiTokensOpen" />
       <InfrastructureWindow v-if="ui.infrastructureOpen" />
       <EnvironmentSetupWizard v-if="ui.environmentWizardOpen" />

package/app/stores/agentPrompts.ts

@@ -0,0 +1,100 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { AgentPromptDetail, AgentPromptSummary } from '~/types/agent-prompts'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * The workspace's agent system-prompt overrides — the pipeline builder's prompt editor.
+ *
+ * Two shapes, deliberately loaded apart. The INDEX (`summaries`) says which agent kinds deviate
+ * from what the product ships and is loaded with the builder, because it badges every step. A
+ * kind's prompt BODIES (`detail`) are loaded only when the editor for that kind opens: a prompt
+ * is thousands of characters and a pipeline has a dozen steps, so folding the bodies into the
+ * index would make opening the builder pay for text nobody read.
+ */
+export const useAgentPromptsStore = defineStore('agentPrompts', () => {
+  const api = useApi()
+
+  const summaries = ref<AgentPromptSummary[]>([])
+  const detail = ref<AgentPromptDetail | null>(null)
+  const loadingIndex = ref(false)
+  const loadingDetail = ref(false)
+  const saving = ref(false)
+
+  /** Agent kinds whose live prompt replaces the shipped one, for the builder's badges. */
+  const customizedKinds = computed(
+    () => new Set(summaries.value.filter((s) => s.customized).map((s) => s.agentKind)),
+  )
+
+  function isCustomized(agentKind: string): boolean {
+    return customizedKinds.value.has(agentKind)
+  }
+
+  /**
+   * Load the override index. Best-effort: the builder is fully usable without it (the badges
+   * are an affordance, not the feature), and the endpoint 503s on a deployment that wires no
+   * override store at all.
+   */
+  async function loadIndex() {
+    const ws = useWorkspaceStore()
+    if (!ws.workspaceId) return
+    loadingIndex.value = true
+    try {
+      summaries.value = await api.listAgentPrompts(ws.requireId())
+    } finally {
+      loadingIndex.value = false
+    }
+  }
+
+  /** Open one kind's editor state. Errors propagate — an editor with no prompt is useless. */
+  async function load(agentKind: string) {
+    const ws = useWorkspaceStore()
+    detail.value = null
+    loadingDetail.value = true
+    try {
+      detail.value = await api.getAgentPrompt(ws.requireId(), agentKind)
+      return detail.value
+    } finally {
+      loadingDetail.value = false
+    }
+  }
+
+  /**
+   * Append a revision: new text, or `null` to go back to the shipped prompt. The server returns
+   * the refreshed detail, so the editor re-renders from the server's view of the log rather
+   * than a locally-guessed one — which is what makes a rejected concurrent save (409) leave the
+   * user looking at what actually landed.
+   */
+  async function save(agentKind: string, text: string | null, restoredFrom?: number) {
+    const ws = useWorkspaceStore()
+    saving.value = true
+    try {
+      detail.value = await api.saveAgentPrompt(ws.requireId(), agentKind, {
+        text,
+        ...(restoredFrom !== undefined ? { restoredFrom } : {}),
+      })
+      await loadIndex()
+      return detail.value
+    } finally {
+      saving.value = false
+    }
+  }
+
+  function reset() {
+    detail.value = null
+  }
+
+  return {
+    summaries,
+    detail,
+    loadingIndex,
+    loadingDetail,
+    saving,
+    customizedKinds,
+    isCustomized,
+    loadIndex,
+    load,
+    save,
+    reset,
+  }
+})

package/app/stores/packageRegistries.spec.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { usePackageRegistriesStore } from '~/stores/packageRegistries'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { PackageRegistryEntryView } from '~/types/packageRegistries'
+
+/**
+ * The availability probe and the list read share one `load()`, but their failure contracts are
+ * opposite, and the split is what these cases pin:
+ *
+ *   - a 503 is an ANSWER ("this deployment has no registries module") and resolves normally, so
+ *     the Infrastructure window simply shows no tab;
+ *   - anything else is a FAILURE that propagates, because the panel — which only renders once
+ *     the probe already succeeded — is the surface that can tell a reader the list they are
+ *     looking at could not be fetched.
+ */
+function entry(over: Partial<PackageRegistryEntryView> = {}): PackageRegistryEntryView {
+  return {
+    id: 'pkgreg_1',
+    ecosystem: 'npm',
+    vendor: 'npmjs',
+    scopes: ['@acme'],
+    tokenTail: 'cdef',
+    ...over,
+  }
+}
+
+describe('packageRegistries store', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('load stores the entries and marks the module available', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listPackageRegistries: () => Promise.resolve({ entries: [entry()] }),
+    }))
+
+    const store = usePackageRegistriesStore()
+    await store.load()
+
+    expect(store.available).toBe(true)
+    expect(store.entries).toHaveLength(1)
+    expect(store.loading).toBe(false)
+  })
+
+  it('a definitive 503 latches the module unavailable without throwing', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listPackageRegistries: () => Promise.reject({ statusCode: 503 }),
+    }))
+
+    const store = usePackageRegistriesStore()
+    await expect(store.load()).resolves.toBeUndefined()
+
+    expect(store.available).toBe(false)
+    expect(store.entries).toEqual([])
+  })
+
+  it('a transient failure propagates and leaves `available` null so the probe stays retryable', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listPackageRegistries: () => Promise.reject({ statusCode: 500 }),
+    }))
+
+    const store = usePackageRegistriesStore()
+    await expect(store.load()).rejects.toMatchObject({ statusCode: 500 })
+
+    // Never cached as a false "unavailable": a reachable-but-flaky backend must not hide a tab
+    // the deployment really has.
+    expect(store.available).toBeNull()
+    expect(store.loading).toBe(false)
+  })
+
+  it('keeps an already-loaded list when a later refresh fails', async () => {
+    let fail = false
+    vi.stubGlobal('useApi', () => ({
+      listPackageRegistries: () =>
+        fail ? Promise.reject({ statusCode: 500 }) : Promise.resolve({ entries: [entry()] }),
+    }))
+
+    const store = usePackageRegistriesStore()
+    await store.load()
+    fail = true
+    await expect(store.load()).rejects.toMatchObject({ statusCode: 500 })
+
+    // The panel reports the failure; it must not also blank the list the reader had.
+    expect(store.available).toBe(true)
+    expect(store.entries).toHaveLength(1)
+  })
+
+  it('ensureLoaded probes once and stays retryable after a transient failure', async () => {
+    let calls = 0
+    let fail = true
+    vi.stubGlobal('useApi', () => ({
+      listPackageRegistries: () => {
+        calls += 1
+        return fail ? Promise.reject({ statusCode: 500 }) : Promise.resolve({ entries: [] })
+      },
+    }))
+
+    const store = usePackageRegistriesStore()
+    await expect(store.ensureLoaded()).rejects.toMatchObject({ statusCode: 500 })
+    expect(calls).toBe(1)
+
+    fail = false
+    await store.ensureLoaded()
+    expect(calls).toBe(2)
+    expect(store.available).toBe(true)
+
+    // Settled now, so a third caller costs no request.
+    await store.ensureLoaded()
+    expect(calls).toBe(2)
+  })
+})

package/app/stores/packageRegistries.ts

@@ -7,8 +7,9 @@ import { apiErrorStatus } from '~/composables/api/errors'
 /**
  * The workspace's private package-registry entries (npm private orgs, GitHub
  * Packages) that agent containers install with. Tokens are write-only — the store
- * only ever holds the redacted summary views. Loaded on demand (the registries
- * panel + the Integrations hub badge), not from the snapshot.
+ * only ever holds the redacted summary views. Loaded on demand (the Infrastructure
+ * window's "Package registries" tab, whose very existence gates on the probe below),
+ * not from the snapshot.
  */
 export const usePackageRegistriesStore = defineStore('packageRegistries', () => {
   const api = useApi()
@@ -16,8 +17,8 @@ export const usePackageRegistriesStore = defineStore('packageRegistries', () =>
   const entries = ref<PackageRegistryEntryView[]>([])
   const loading = ref(false)
   // Mirrors the backend's opt-in gate (the module 503s when the encryption key is
-  // absent): `null` until first probed, then `true`/`false`. The hub hides its
-  // registries entry point when this is false.
+  // absent): `null` until first probed, then `true`/`false`. The Infrastructure window
+  // shows no registries tab unless this is `true`.
   const available = ref<boolean | null>(null)
   let inFlight: Promise<void> | null = null
 
@@ -31,13 +32,25 @@ export const usePackageRegistriesStore = defineStore('packageRegistries', () =>
     } catch (err) {
       if (apiErrorStatus(err) === 503) {
         // A definitive 503 means the integration is unconfigured (no encryption key on
-        // the backend): hide the UI entry points and stop probing.
+        // the backend): hide the UI entry points and stop probing. This is an ANSWER, not a
+        // failure, so it resolves normally.
         available.value = false
         entries.value = []
+        return
       }
-      // Any other failure (transient 5xx / network) is left untouched: it must not hide
-      // an already-available panel nor cache a false "unavailable". `available` stays
-      // `null` when never probed, so `ensureLoaded` remains retryable on the next open.
+      // Any other failure (transient 5xx / network) leaves the state untouched: it must not
+      // hide an already-available panel nor cache a false "unavailable". `available` stays
+      // `null` when never probed, so `ensureLoaded` remains retryable on the next open — and
+      // the error PROPAGATES so a caller can say so. Swallowing it made every caller's error
+      // branch dead code: "the backend is unreachable" and "your deployment has no registries
+      // module" are different problems that must not render identically, and the panel is the
+      // one surface that can tell a reader which it hit. The PROBE callers still swallow (a
+      // failed probe means no tab, not a broken window) — the split is deliberate.
+      //
+      // NB `publicApiKeys` carries the same availability shape and still swallows here. It is
+      // not being changed alongside: its probe only hides one row of a hub full of others,
+      // whereas this one gates the feature's ONLY surface.
+      throw err
     } finally {
       loading.value = false
     }

package/app/stores/sandbox.ts

@@ -111,6 +111,20 @@ export const useSandboxStore = defineStore('sandbox', () => {
     return saved
   }
 
+  /**
+   * Promote a prompt version to the workspace's live prompt for its agent kind — the deploy half
+   * of the sandbox workflow. Reloads so the projected `workspace` rows (and their `live` marker)
+   * reflect the new head, and refreshes the prompt-override index the pipeline builder badges from
+   * so the two surfaces cannot disagree about what is running.
+   */
+  async function promotePrompt(version: SandboxPromptVersion) {
+    const ws = useWorkspaceStore()
+    const detail = await api.promoteAgentPrompt(ws.requireId(), version.agentKind, version.id)
+    await load()
+    await useAgentPromptsStore().loadIndex()
+    return detail
+  }
+
   async function archivePrompt(promptId: string) {
     const ws = useWorkspaceStore()
     await api.archiveSandboxPrompt(ws.requireId(), promptId)
@@ -164,6 +178,7 @@ export const useSandboxStore = defineStore('sandbox', () => {
     promptsForKind,
     fixturesForKind,
     clonePrompt,
+    promotePrompt,
     saveVersion,
     archivePrompt,
     createExperiment,