@cat-factory/app 0.93.0 → 0.95.0

package/app/components/settings/SharedStacksPanel.vue

@@ -0,0 +1,363 @@
+<script setup lang="ts">
+// Shared stacks — long-lived compose infra (e.g. acme-shared-services: MySQL / Postgres /
+// Valkey / RabbitMQ / Kafka / ES / Mailpit / Envoy) brought up ONCE per workspace and reused
+// across runs + PRs. A per-PR consumer environment attaches to a stack's managed network. CRUD
+// works on every backend; the bring-up (Start) / teardown (Stop) drive a host Docker daemon, so
+// they succeed only on the local facade (elsewhere the backend returns a clear error surfaced as
+// a toast). Renders inline inside the Infrastructure window's "Shared stacks" tab.
+import { computed, reactive, ref } from 'vue'
+import type { SharedStack, SharedStackStatus } from '~/types/sharedStacks'
+
+const { t } = useI18n()
+const store = useSharedStacksStore()
+const toast = useToast()
+const { confirmAction, toastDone } = useConfirmAction()
+
+const stacks = computed(() => store.stacks)
+const busyId = ref<string | null>(null)
+const saving = ref(false)
+// null ⇒ the form is in "add" mode; a stack id ⇒ editing that stack's definition in place.
+const editingId = ref<string | null>(null)
+
+const form = reactive({
+  name: '',
+  cloneUrl: '',
+  gitRef: '',
+  composeFiles: '',
+  composeProfiles: '',
+  managedNetworks: '',
+  allowHostCommands: false,
+})
+
+/** Status → badge colour. */
+const STATUS_COLOR: Record<SharedStackStatus, 'neutral' | 'warning' | 'success' | 'error'> = {
+  stopped: 'neutral',
+  starting: 'warning',
+  running: 'success',
+  failed: 'error',
+}
+
+// Status → catalog key as an EXHAUSTIVE Record over the enum (not a runtime-assembled key), so a
+// new SharedStackStatus fails the typecheck on this map instead of leaking a raw key into the badge.
+const STATUS_LABEL_KEYS: Record<SharedStackStatus, string> = {
+  stopped: 'settings.sharedStacks.status.stopped',
+  starting: 'settings.sharedStacks.status.starting',
+  running: 'settings.sharedStacks.status.running',
+  failed: 'settings.sharedStacks.status.failed',
+}
+
+function statusLabel(status: SharedStackStatus): string {
+  return t(STATUS_LABEL_KEYS[status])
+}
+
+/** A running/starting stack cannot be reconfigured (the backend refuses) — edit is stopped/failed only. */
+function canEdit(stack: SharedStack): boolean {
+  return stack.status !== 'running' && stack.status !== 'starting'
+}
+
+/** Split a comma/whitespace-separated field into trimmed non-empty tokens. */
+function tokens(value: string): string[] {
+  return value
+    .split(/[\s,]+/)
+    .map((s) => s.trim())
+    .filter(Boolean)
+}
+
+const canSave = computed(
+  () => form.name.trim() && form.cloneUrl.trim() && tokens(form.composeFiles).length > 0,
+)
+
+function resetForm() {
+  editingId.value = null
+  form.name = ''
+  form.cloneUrl = ''
+  form.gitRef = ''
+  form.composeFiles = ''
+  form.composeProfiles = ''
+  form.managedNetworks = ''
+  form.allowHostCommands = false
+}
+
+/** Load a stack's definition into the form for in-place editing. */
+function startEdit(stack: SharedStack) {
+  editingId.value = stack.id
+  form.name = stack.name
+  form.cloneUrl = stack.cloneUrl
+  form.gitRef = stack.gitRef ?? ''
+  form.composeFiles = stack.composeFiles.join(', ')
+  form.composeProfiles = stack.composeProfiles.join(', ')
+  form.managedNetworks = stack.managedNetworks.join(', ')
+  form.allowHostCommands = stack.allowHostCommands
+}
+
+function notifyError(title: string, e: unknown) {
+  toast.add({
+    title,
+    description: e instanceof Error ? e.message : String(e),
+    icon: 'i-lucide-triangle-alert',
+    color: 'error',
+  })
+}
+
+/** Create a new stack, or save edits to the one being edited (same form, mode toggled by `editingId`). */
+async function saveStack() {
+  saving.value = true
+  const editing = editingId.value
+  const payload = {
+    name: form.name.trim(),
+    cloneUrl: form.cloneUrl.trim(),
+    ...(form.gitRef.trim() ? { gitRef: form.gitRef.trim() } : {}),
+    composeFiles: tokens(form.composeFiles),
+    composeProfiles: tokens(form.composeProfiles),
+    managedNetworks: tokens(form.managedNetworks),
+    allowHostCommands: form.allowHostCommands,
+  }
+  try {
+    if (editing) {
+      await store.update(editing, { ...payload, gitRef: form.gitRef.trim() || null })
+    } else {
+      await store.create(payload)
+    }
+    resetForm()
+    toast.add({
+      title: t(
+        editing ? 'settings.sharedStacks.toast.updated' : 'settings.sharedStacks.toast.created',
+      ),
+      icon: 'i-lucide-check',
+      color: 'success',
+    })
+  } catch (e) {
+    notifyError(
+      t(
+        editing
+          ? 'settings.sharedStacks.toast.updateFailed'
+          : 'settings.sharedStacks.toast.createFailed',
+      ),
+      e,
+    )
+  } finally {
+    saving.value = false
+  }
+}
+
+async function start(stack: SharedStack) {
+  busyId.value = stack.id
+  try {
+    // ensureUp resolves 200 even on a FAILED bring-up (the record carries status/lastError), so
+    // surface that as an error toast too — not only a thrown transport/unavailable error.
+    const updated = await store.ensureUp(stack.id)
+    if (updated.status === 'failed') {
+      notifyError(t('settings.sharedStacks.toast.startFailed'), updated.lastError ?? '')
+    }
+  } catch (e) {
+    notifyError(t('settings.sharedStacks.toast.startFailed'), e)
+  } finally {
+    busyId.value = null
+  }
+}
+
+async function stop(stack: SharedStack) {
+  busyId.value = stack.id
+  try {
+    await store.teardown(stack.id)
+  } catch (e) {
+    notifyError(t('settings.sharedStacks.toast.stopFailed'), e)
+  } finally {
+    busyId.value = null
+  }
+}
+
+async function remove(stack: SharedStack) {
+  const noun = t('settings.sharedStacks.stackNoun')
+  if (!(await confirmAction('remove', noun))) return
+  busyId.value = stack.id
+  try {
+    await store.remove(stack.id)
+    toastDone('remove', noun)
+  } catch (e) {
+    notifyError(t('settings.sharedStacks.toast.removeFailed'), e)
+  } finally {
+    busyId.value = null
+  }
+}
+</script>
+
+<template>
+  <div class="space-y-4" data-testid="shared-stacks-panel">
+    <p class="text-sm text-slate-400">{{ t('settings.sharedStacks.intro') }}</p>
+
+    <section v-if="stacks.length" class="space-y-2 rounded-lg border border-slate-700 p-3">
+      <h3 class="text-sm font-semibold">{{ t('settings.sharedStacks.list.heading') }}</h3>
+      <div
+        v-for="stack in stacks"
+        :key="stack.id"
+        class="space-y-2 rounded-md border border-slate-800 px-3 py-2"
+        :data-testid="`shared-stack-${stack.id}`"
+      >
+        <div class="flex items-center justify-between gap-2">
+          <div class="min-w-0 space-y-1">
+            <div class="flex items-center gap-2">
+              <span class="text-sm font-medium">{{ stack.name }}</span>
+              <UBadge :color="STATUS_COLOR[stack.status]" variant="soft" size="sm">
+                {{ statusLabel(stack.status) }}
+              </UBadge>
+            </div>
+            <p class="truncate text-[11px] text-slate-500">{{ stack.cloneUrl }}</p>
+            <div v-if="stack.managedNetworks.length" class="flex flex-wrap gap-1">
+              <UBadge
+                v-for="net in stack.managedNetworks"
+                :key="net"
+                color="neutral"
+                variant="soft"
+                size="sm"
+              >
+                {{ net }}
+              </UBadge>
+            </div>
+          </div>
+          <div class="flex shrink-0 items-center gap-1">
+            <UButton
+              v-if="stack.status !== 'running'"
+              icon="i-lucide-play"
+              size="sm"
+              variant="soft"
+              :loading="busyId === stack.id"
+              :data-testid="`shared-stack-start-${stack.id}`"
+              @click="start(stack)"
+            >
+              {{ t('settings.sharedStacks.list.start') }}
+            </UButton>
+            <UButton
+              v-else
+              icon="i-lucide-square"
+              size="sm"
+              variant="soft"
+              color="warning"
+              :loading="busyId === stack.id"
+              :data-testid="`shared-stack-stop-${stack.id}`"
+              @click="stop(stack)"
+            >
+              {{ t('settings.sharedStacks.list.stop') }}
+            </UButton>
+            <UButton
+              v-if="canEdit(stack)"
+              color="neutral"
+              variant="ghost"
+              icon="i-lucide-pencil"
+              size="sm"
+              :data-testid="`shared-stack-edit-${stack.id}`"
+              :aria-label="t('settings.sharedStacks.list.edit')"
+              @click="startEdit(stack)"
+            />
+            <UButton
+              color="error"
+              variant="ghost"
+              icon="i-lucide-trash-2"
+              size="sm"
+              :loading="busyId === stack.id"
+              :data-testid="`shared-stack-delete-${stack.id}`"
+              :aria-label="t('settings.sharedStacks.list.remove')"
+              @click="remove(stack)"
+            />
+          </div>
+        </div>
+        <p v-if="stack.lastError" class="text-[11px] text-rose-400">{{ stack.lastError }}</p>
+      </div>
+    </section>
+
+    <section
+      class="space-y-3 rounded-lg border border-slate-700 p-3"
+      data-testid="shared-stack-form"
+    >
+      <h3 class="text-sm font-semibold">
+        {{
+          t(editingId ? 'settings.sharedStacks.edit.heading' : 'settings.sharedStacks.add.heading')
+        }}
+      </h3>
+
+      <UFormField :label="t('settings.sharedStacks.add.name')">
+        <UInput v-model="form.name" class="w-full" data-testid="shared-stack-name" />
+      </UFormField>
+
+      <UFormField
+        :label="t('settings.sharedStacks.add.cloneUrl')"
+        :help="t('settings.sharedStacks.add.cloneUrlHelp')"
+      >
+        <UInput
+          v-model="form.cloneUrl"
+          placeholder="https://github.com/acme/acme-shared-services.git"
+          class="w-full"
+          data-testid="shared-stack-clone-url"
+        />
+      </UFormField>
+
+      <UFormField :label="t('settings.sharedStacks.add.gitRef')">
+        <UInput
+          v-model="form.gitRef"
+          placeholder="main"
+          class="w-full"
+          data-testid="shared-stack-git-ref"
+        />
+      </UFormField>
+
+      <UFormField
+        :label="t('settings.sharedStacks.add.composeFiles')"
+        :help="t('settings.sharedStacks.add.composeFilesHelp')"
+      >
+        <UInput
+          v-model="form.composeFiles"
+          placeholder="docker-compose.yml, docker-compose.override.yml"
+          class="w-full"
+          data-testid="shared-stack-compose-files"
+        />
+      </UFormField>
+
+      <UFormField :label="t('settings.sharedStacks.add.composeProfiles')">
+        <UInput
+          v-model="form.composeProfiles"
+          placeholder="backends, peer"
+          class="w-full"
+          data-testid="shared-stack-profiles"
+        />
+      </UFormField>
+
+      <UFormField
+        :label="t('settings.sharedStacks.add.managedNetworks')"
+        :help="t('settings.sharedStacks.add.managedNetworksHelp')"
+      >
+        <UInput
+          v-model="form.managedNetworks"
+          placeholder="acme-net"
+          class="w-full"
+          data-testid="shared-stack-networks"
+        />
+      </UFormField>
+
+      <UCheckbox
+        v-model="form.allowHostCommands"
+        :label="t('settings.sharedStacks.add.allowHostCommands')"
+        data-testid="shared-stack-allow-host-commands"
+      />
+
+      <div class="flex items-center gap-2">
+        <UButton
+          :loading="saving"
+          :disabled="!canSave"
+          data-testid="shared-stack-save"
+          @click="saveStack"
+        >
+          {{ t(editingId ? 'settings.sharedStacks.edit.save' : 'settings.sharedStacks.add.save') }}
+        </UButton>
+        <UButton
+          v-if="editingId"
+          color="neutral"
+          variant="ghost"
+          data-testid="shared-stack-cancel-edit"
+          @click="resetForm"
+        >
+          {{ t('settings.sharedStacks.edit.cancel') }}
+        </UButton>
+      </div>
+    </section>
+  </div>
+</template>

package/app/composables/api/sharedStacks.ts

@@ -0,0 +1,42 @@
+import {
+  createSharedStackContract,
+  deleteSharedStackContract,
+  ensureSharedStackUpContract,
+  listSharedStacksContract,
+  teardownSharedStackContract,
+  updateSharedStackContract,
+} from '@cat-factory/contracts'
+import type { UpdateSharedStackInput } from '~/types/sharedStacks'
+import type { SendParams } from './client'
+import type { ApiContext } from './context'
+
+// The create body is typed from the contract's INPUT shape so the valibot-defaulted array fields
+// (profiles, envFiles, managedNetworks, setupSteps, allowHostCommands) stay optional for callers.
+type CreateSharedStackBody = NonNullable<SendParams<typeof createSharedStackContract>['body']>
+
+/** A workspace's shared stacks: CRUD plus the ensure-up / teardown lifecycle actions. */
+export function sharedStacksApi({ send, ws }: ApiContext) {
+  return {
+    listSharedStacks: (workspaceId: string) =>
+      send(listSharedStacksContract, { pathPrefix: ws(workspaceId) }),
+
+    createSharedStack: (workspaceId: string, body: CreateSharedStackBody) =>
+      send(createSharedStackContract, { pathPrefix: ws(workspaceId), body }),
+
+    updateSharedStack: (workspaceId: string, stackId: string, body: UpdateSharedStackInput) =>
+      send(updateSharedStackContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { stackId },
+        body,
+      }),
+
+    deleteSharedStack: (workspaceId: string, stackId: string) =>
+      send(deleteSharedStackContract, { pathPrefix: ws(workspaceId), pathParams: { stackId } }),
+
+    ensureSharedStackUp: (workspaceId: string, stackId: string) =>
+      send(ensureSharedStackUpContract, { pathPrefix: ws(workspaceId), pathParams: { stackId } }),
+
+    teardownSharedStack: (workspaceId: string, stackId: string) =>
+      send(teardownSharedStackContract, { pathPrefix: ws(workspaceId), pathParams: { stackId } }),
+  }
+}

package/app/composables/useApi.ts

@@ -22,6 +22,7 @@ import { modelsApi } from './api/models'
 import { notificationsApi } from './api/notifications'
 import { packageRegistriesApi } from './api/packageRegistries'
 import { presetsApi } from './api/presets'
+import { sharedStacksApi } from './api/sharedStacks'
 import { providerConnectionsApi } from './api/providerConnections'
 import { provisioningLogsApi } from './api/provisioningLogs'
 import { recurringApi } from './api/recurring'
@@ -112,6 +113,7 @@ export function useApi() {
     ...specApi(ctx),
     ...notificationsApi(ctx),
     ...presetsApi(ctx),
+    ...sharedStacksApi(ctx),
     ...providerConnectionsApi(ctx),
     ...infraHandlersApi(ctx),
     ...initiativeApi(ctx),

package/app/composables/useRepoSearch.ts

@@ -0,0 +1,66 @@
+import { computed, ref, watch } from 'vue'
+import { refDebounced } from '@vueuse/core'
+import type { GitHubAvailableRepo } from '~/types/domain'
+
+/** Minimum characters before a search fires — a wide install has too many repos to prefetch. */
+export const REPO_SEARCH_MIN_LEN = 3
+
+/** How the picker searches: a debounced, min-length-gated, server-side repo search. */
+export type RepoFetcher = (query: string) => Promise<GitHubAvailableRepo[]>
+
+/**
+ * Shared repo-lookup behaviour for the GitHub repo pickers (the add-service modal and the
+ * doc-task reference-repo picker). A wide App install / PAT can expose hundreds of repos, so the
+ * pickers search SERVER-SIDE rather than prefetching and filtering in the browser: once the user
+ * types at least {@link REPO_SEARCH_MIN_LEN} characters the (debounced) query is sent to the
+ * backend, which returns only the matches. Below the gate the list stays empty and the caller
+ * shows a "type N chars" hint.
+ *
+ * The fetcher defaults to the github store's NON-mutating `searchAvailableRepos`, so each picker
+ * keeps its OWN result list — two pickers never clobber each other through the shared
+ * `availableRepos` singleton. A stale-response guard drops an out-of-order fetch so fast typing
+ * can't leave older matches showing.
+ */
+export function useRepoSearch(fetcher?: RepoFetcher) {
+  const github = useGitHubStore()
+  const doFetch: RepoFetcher = fetcher ?? ((q) => github.searchAvailableRepos(q))
+
+  const search = ref('')
+  const debounced = refDebounced(search, 250)
+  // Trimmed for the min-length gate; the backend matches case-insensitively.
+  const query = computed(() => debounced.value.trim())
+  const belowMinChars = computed(() => query.value.length < REPO_SEARCH_MIN_LEN)
+
+  const results = ref<GitHubAvailableRepo[]>([])
+  const loading = ref(false)
+  // Monotonic token so a slow earlier fetch can't overwrite a faster later one.
+  let seq = 0
+
+  watch(query, async (q) => {
+    if (q.length < REPO_SEARCH_MIN_LEN) {
+      results.value = []
+      return
+    }
+    const mine = ++seq
+    loading.value = true
+    try {
+      const found = await doFetch(q)
+      if (mine === seq) results.value = found
+    } finally {
+      if (mine === seq) loading.value = false
+    }
+  })
+
+  /** Clear the search term and results (e.g. after a pick, or when the host closes). */
+  function reset() {
+    search.value = ''
+    results.value = []
+    // Bump the token so an in-flight fetch's result/finally is ignored — and clear `loading`
+    // ourselves, since that same in-flight `finally` will now skip its `mine === seq` guard and
+    // would otherwise leave the spinner stuck on until the next search completes.
+    seq++
+    loading.value = false
+  }
+
+  return { search, query, belowMinChars, results, loading, reset }
+}

package/app/stores/github.ts

@@ -157,6 +157,18 @@ export const useGitHubStore = defineStore('github', () => {
     }
   }
 
+  /**
+   * Search the installation/PAT-accessible repos server-side WITHOUT touching the shared
+   * `availableRepos`/`loadingAvailable` singleton — it returns the matches to the caller instead.
+   * This is the reusable form behind {@link useRepoSearch}: two independent pickers (the
+   * add-service modal and the doc-task reference-repo picker) can search concurrently without
+   * clobbering each other's results. A blank/short `q` (or no connection) returns `[]`.
+   */
+  async function searchAvailableRepos(q: string): Promise<GitHubAvailableRepo[]> {
+    if (!connected.value || q.trim() === '') return []
+    return api.listGitHubAvailableRepos(workspace.requireId(), q)
+  }
+
   /** Set the exact set of repos this workspace links, then refresh projections. */
   async function setLinkedRepos(repoGithubIds: number[]) {
     savingRepos.value = true
@@ -318,6 +330,7 @@ export const useGitHubStore = defineStore('github', () => {
     load,
     ensureLoaded,
     loadAvailableRepos,
+    searchAvailableRepos,
     setLinkedRepos,
     loadRepoTree,
     loadBranches,

package/app/stores/sharedStacks.ts

@@ -0,0 +1,65 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { SharedStack, UpdateSharedStackInput } from '~/types/sharedStacks'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * The workspace's shared stacks — long-lived compose infra (e.g. acme-shared-services) that
+ * per-PR consumer environments attach to over an external network. Hydrated from the workspace
+ * snapshot; managed via the Infrastructure window's "Shared stacks" panel. CRUD works on every
+ * backend, but the bring-up (`ensureUp`) / teardown drive a host Docker daemon, so they succeed
+ * only on the local facade (elsewhere the backend returns a clear error the panel surfaces).
+ *
+ * Mutations refresh the workspace snapshot (the stack list rides it), while the async lifecycle
+ * actions patch the returned record in place so the panel shows the new status immediately.
+ */
+export const useSharedStacksStore = defineStore('sharedStacks', () => {
+  const api = useApi()
+  const stacks = ref<SharedStack[]>([])
+
+  function hydrate(list: SharedStack[]) {
+    stacks.value = [...list].sort((a, b) => a.createdAt - b.createdAt)
+  }
+
+  function patch(stack: SharedStack) {
+    const idx = stacks.value.findIndex((s) => s.id === stack.id)
+    if (idx >= 0) stacks.value[idx] = stack
+    else stacks.value.push(stack)
+  }
+
+  async function create(input: Parameters<typeof api.createSharedStack>[1]) {
+    const ws = useWorkspaceStore()
+    const created = await api.createSharedStack(ws.requireId(), input)
+    await ws.refresh()
+    return created
+  }
+
+  async function update(stackId: string, patchInput: UpdateSharedStackInput) {
+    const ws = useWorkspaceStore()
+    const updated = await api.updateSharedStack(ws.requireId(), stackId, patchInput)
+    await ws.refresh()
+    return updated
+  }
+
+  async function remove(stackId: string) {
+    const ws = useWorkspaceStore()
+    await api.deleteSharedStack(ws.requireId(), stackId)
+    await ws.refresh()
+  }
+
+  async function ensureUp(stackId: string) {
+    const ws = useWorkspaceStore()
+    const updated = await api.ensureSharedStackUp(ws.requireId(), stackId)
+    patch(updated)
+    return updated
+  }
+
+  async function teardown(stackId: string) {
+    const ws = useWorkspaceStore()
+    const updated = await api.teardownSharedStack(ws.requireId(), stackId)
+    patch(updated)
+    return updated
+  }
+
+  return { stacks, hydrate, create, update, remove, ensureUp, teardown }
+})

package/app/stores/workspace.ts

@@ -8,6 +8,7 @@ import { useExecutionStore } from '~/stores/execution'
 import { useAgentRunsStore } from '~/stores/agentRuns'
 import { useNotificationsStore } from '~/stores/notifications'
 import { useMergePresetsStore } from '~/stores/mergePresets'
+import { useSharedStacksStore } from '~/stores/sharedStacks'
 import { useWorkspaceSettingsStore } from '~/stores/workspaceSettings'
 import { useAgentConfigStore } from '~/stores/agentConfig'
 import { useModelPresetsStore } from '~/stores/modelPresets'
@@ -107,6 +108,7 @@ export const useWorkspaceStore = defineStore(
         snapshot.mergePresets ?? [],
         snapshot.mergePresetCatalogVersions,
       )
+      useSharedStacksStore().hydrate(snapshot.sharedStacks ?? [])
       useWorkspaceSettingsStore().hydrate(snapshot.settings)
       useAgentConfigStore().hydrate(snapshot.agentConfigCatalog ?? [])
       useModelPresetsStore().hydrate(snapshot.modelPresets ?? [])

package/app/types/domain.ts

@@ -28,6 +28,7 @@ export type {
   DocKindFieldSpec,
   Block,
   PullRequestRef,
+  ReferenceRepo,
   CloudProvider,
   InstanceSize,
   ProvisionType,

package/app/types/sharedStacks.ts

@@ -0,0 +1,8 @@
+// Wire types for shared stacks — long-lived compose infra a consumer environment attaches to
+// over an external network. Re-exported from the single source of truth (`@cat-factory/contracts`).
+export type {
+  SharedStack,
+  SharedStackStatus,
+  CreateSharedStackInput,
+  UpdateSharedStackInput,
+} from '@cat-factory/contracts'

package/i18n/locales/en.json

@@ -876,6 +876,12 @@
       "involvedServicesHint": "Connected services directly involved in this task: each spins up as an ephemeral environment alongside this task's own service, and the coding agent may change their repositories too.",
       "involvedServicesEmpty": "No connected services. Connect services on the service frame to select them here.",
       "involvedServiceStale": "No longer connected to this task's service; it is dropped on the next change."
+    },
+    "referenceRepos": {
+      "title": "Reference repositories",
+      "remove": "Remove {repo}",
+      "connectFirst": "Connect GitHub to attach reference repositories.",
+      "hint": "The document writer clones these read-only to reuse existing solutions as a reference while drafting. It never changes them."
     }
   },
   "panels": {
@@ -2155,6 +2161,52 @@
         "removeFailed": "Could not remove the registry entry"
       }
     },
+    "sharedStacks": {
+      "tab": "Shared stacks",
+      "intro": "Long-lived compose infrastructure (databases, brokers, search, mail) brought up once per workspace and reused across runs and pull requests. A test environment attaches to a stack's managed network. Bringing a stack up runs on a local Docker deployment; on other backends you can still manage the definition.",
+      "stackNoun": "shared stack",
+      "status": {
+        "stopped": "Stopped",
+        "starting": "Starting",
+        "running": "Running",
+        "failed": "Failed"
+      },
+      "list": {
+        "heading": "Configured stacks",
+        "start": "Start",
+        "stop": "Stop",
+        "edit": "Edit",
+        "remove": "Delete stack"
+      },
+      "add": {
+        "heading": "Add a shared stack",
+        "name": "Name",
+        "cloneUrl": "Repository clone URL",
+        "cloneUrlHelp": "The git repository the stack's compose files live in.",
+        "gitRef": "Branch or tag (optional)",
+        "composeFiles": "Compose files",
+        "composeFilesHelp": "Comma-separated, repo-relative, in override order.",
+        "composeProfiles": "Compose profiles (optional)",
+        "managedNetworks": "Managed networks (optional)",
+        "managedNetworksHelp": "Networks this stack creates and owns for consumers to attach to.",
+        "allowHostCommands": "Allow host-command setup steps",
+        "save": "Add stack"
+      },
+      "edit": {
+        "heading": "Edit shared stack",
+        "save": "Save changes",
+        "cancel": "Cancel"
+      },
+      "toast": {
+        "created": "Shared stack added",
+        "createFailed": "Could not add the shared stack",
+        "updated": "Shared stack updated",
+        "updateFailed": "Could not update the shared stack",
+        "startFailed": "Could not start the shared stack",
+        "stopFailed": "Could not stop the shared stack",
+        "removeFailed": "Could not delete the shared stack"
+      }
+    },
     "localMode": {
       "title": "Local mode",
       "intro": "Tuning for the local container runner, stored on this machine's deployment (it replaced the {poolVars} / {harnessVars} env vars). Saving resizes the warm pool live, no restart needed; in-flight runs keep the container they already hold.",