@cat-factory/app 0.51.1 → 0.53.0

package/app/components/layout/SideBar.vue

@@ -24,11 +24,15 @@ const auth = useAuthStore()
 const providerConnections = useProviderConnectionsStore()
 const ui = useUiStore()
 
-// The Infrastructure menu (agent-container execution + test environments) is relevant when
-// either provider integration is available OR we're running the local-mode facade (which
-// always has host-Docker execution + the warm-pool/checkout settings to configure).
+// The Infrastructure menu (agent-container execution + test environments) shows whenever the
+// deployment reports its infrastructure capability — every facade populates `auth.infrastructure`
+// (it drives the execution-backend selector), so there is always an execution + test-env backend
+// to view, even on a Worker/Node deployment with no runner-pool/environment connection registered.
+// The old provider-availability/local-mode signals stay as a defensive fallback for a backend that
+// (somehow) omits the descriptor.
 const showInfrastructure = computed(
   () =>
+    auth.infrastructure != null ||
     auth.localMode?.enabled === true ||
     providerConnections.isAvailable('runner-pool') ||
     providerConnections.isAvailable('environment'),

package/app/components/settings/InfrastructureWindow.vue

@@ -29,9 +29,12 @@ const open = computed({
 
 const isLocal = computed(() => auth.localMode?.enabled === true)
 
-// Each concern gates on its own availability probe; an unavailable tab isn't offered.
-const agentsAvailable = computed(() => store.isAvailable('runner-pool'))
-const envsAvailable = computed(() => store.isAvailable('environment'))
+// The tabs are driven by the deployment's infrastructure capability (every facade reports
+// execution + test-env backends), NOT the optional provider-connection probes — the execution-
+// backend selector must show even when no runner-pool / environment connection is registered.
+// The connect form inside each tab still gates on its own probe (see the template).
+const agentsAvailable = computed(() => (auth.infrastructure?.execution.available.length ?? 0) > 0)
+const envsAvailable = computed(() => (auth.infrastructure?.testEnv.available.length ?? 0) > 0)
 
 const tabs = computed(() => {
   const out: { value: ProviderConnectionKind; label: string; icon: string; slot: string }[] = []
@@ -102,7 +105,8 @@ watch([tabs, () => store.loaded], () => {
             <div class="space-y-4">
               <!-- Where agent containers run (writable in local mode; read-only elsewhere). -->
               <ExecutionBackendSelector axis="execution" />
-              <ProviderConnectionTab kind="runner-pool" />
+              <!-- The runner-pool connect form only when that integration is enabled. -->
+              <ProviderConnectionTab v-if="store.isAvailable('runner-pool')" kind="runner-pool" />
               <!-- Local mode: the warm-pool + checkout reuse ARE the host agent-container
                    runtime, so they live here rather than in a separate menu. -->
               <section v-if="isLocal" class="border-t border-slate-800 pt-4">
@@ -117,7 +121,8 @@ watch([tabs, () => store.loaded], () => {
             <div class="space-y-4">
               <!-- Where Tester environments run (writable in local mode; read-only elsewhere). -->
               <ExecutionBackendSelector axis="testEnv" />
-              <ProviderConnectionTab kind="environment" />
+              <!-- The environment-provider connect form only when that integration is enabled. -->
+              <ProviderConnectionTab v-if="store.isAvailable('environment')" kind="environment" />
             </div>
           </template>
         </UTabs>

package/app/components/settings/ProviderConnectionTab.vue

@@ -88,6 +88,7 @@ const canSave = computed(() => {
 function buildManifestPayload(): {
   manifest: Record<string, unknown>
   secrets: Record<string, string>
+  backendKind: string
 } | null {
   const template = descriptor.value?.manifestTemplate
   if (!template) return null
@@ -106,7 +107,9 @@ function buildManifestPayload(): {
     else providerConfig[f.key] = val
   }
   if (Object.keys(providerConfig).length) manifest.providerConfig = providerConfig
-  return { manifest, secrets }
+  // Carry the selected kind so a CUSTOM backend's flat-form save is tagged with its slug
+  // (not silently wrapped into the built-in `manifest` backend).
+  return { manifest, secrets, backendKind: backendKind.value }
 }
 
 function notifyError(title: string, e: unknown) {
@@ -156,6 +159,8 @@ async function saveNative() {
 }
 
 // --- Manifest-editor actions (emitted from ProviderManifestEditor) ------------------
+// Tag the raw-manifest save/test with the selected backend kind too, so a CUSTOM kind that
+// ships no flat-form template (and thus uses the raw editor) isn't mis-tagged as `manifest`.
 async function testManifest(payload: {
   manifest: Record<string, unknown>
   secrets: Record<string, string>
@@ -163,7 +168,7 @@ async function testManifest(payload: {
   testing.value = true
   testResult.value = null
   try {
-    testResult.value = await store.test(props.kind, payload)
+    testResult.value = await store.test(props.kind, { ...payload, backendKind: backendKind.value })
   } catch (e) {
     testResult.value = { ok: false, message: e instanceof Error ? e.message : String(e) }
   } finally {
@@ -177,7 +182,7 @@ async function saveManifest(payload: {
 }) {
   busy.value = true
   try {
-    await store.register(props.kind, payload)
+    await store.register(props.kind, { ...payload, backendKind: backendKind.value })
     toastSaved()
   } catch (e) {
     notifyError(t('settings.providerConnection.toast.saveFailed'), e)
@@ -187,14 +192,12 @@ async function saveManifest(payload: {
 }
 
 // --- Backend selector -----------------------------------------------------------------
-// Both infrastructure tabs can configure either the BYO manifest backend OR a native
-// Kubernetes backend (a runner cluster for runner-pool, per-PR namespaces for environment).
-// The two K8s backends have different config shapes, so each kind renders its own form.
-// Defaults to the saved connection's kind.
-const BACKEND_KINDS = ['manifest', 'kubernetes'] as const
-type BackendKind = (typeof BACKEND_KINDS)[number]
-const backendKind = ref<BackendKind>('manifest')
-const showBackendSelector = computed(() => true)
+// Each infrastructure tab configures one of the backend KINDS registered for its subsystem:
+// the built-in BYO `manifest` backend, the native `kubernetes` backend, or any CUSTOM kind a
+// deployment registered programmatically. The list is snapshot-driven (built-in fallback in
+// the store until it loads); the two K8s backends have bespoke forms, every other kind
+// (manifest + custom) uses the descriptor-driven flat form. Defaults to the saved kind.
+const backendKind = ref<string>('manifest')
 const backendSelectorLabel = computed(() =>
   t(
     props.kind === 'environment'
@@ -202,25 +205,40 @@ const backendSelectorLabel = computed(() =>
       : 'settings.providerConnection.backend.selectorLabel',
   ),
 )
-function backendKindLabel(k: BackendKind): string {
-  if (k === 'kubernetes') return t('settings.providerConnection.backend.kubernetes')
-  return t(
-    props.kind === 'environment'
-      ? 'settings.providerConnection.backend.environmentManifest'
-      : 'settings.providerConnection.backend.manifest',
-  )
+// Built-in kinds keep their localized labels; a custom kind shows its snapshot displayLabel.
+function backendKindLabel(option: { kind: string; label: string }): string {
+  if (option.kind === 'kubernetes') return t('settings.providerConnection.backend.kubernetes')
+  if (option.kind === 'manifest') {
+    return t(
+      props.kind === 'environment'
+        ? 'settings.providerConnection.backend.environmentManifest'
+        : 'settings.providerConnection.backend.manifest',
+    )
+  }
+  return option.label
 }
 const backendKindItems = computed(() =>
-  BACKEND_KINDS.map((k) => ({ label: backendKindLabel(k), value: k })),
+  store.backendKindsFor(props.kind).map((o) => ({ label: backendKindLabel(o), value: o.kind })),
 )
 watch(
   () => connection.value,
   (c) => {
-    if (c?.kind === 'kubernetes' || c?.kind === 'manifest') backendKind.value = c.kind
+    if (c?.kind) backendKind.value = c.kind
   },
   { immediate: true },
 )
 
+// Switching the backend kind re-probes ONLY that kind's descriptor (so a not-yet-connected
+// custom kind's connect form renders). Always pass the explicit kind — including `manifest`,
+// so picking it describes the manifest backend rather than falling back to the stored kind —
+// and use `loadDescriptor` (not `loadKind`) so the stored connection isn't re-fetched and the
+// selector isn't bounced back to the stored kind by the `connection` watch.
+async function onBackendKindChange(k: string) {
+  backendKind.value = k
+  await store.loadDescriptor(props.kind, k)
+  resetDraft()
+}
+
 async function testConfig(payload: {
   config: Record<string, unknown>
   secrets: Record<string, string>
@@ -332,9 +350,14 @@ function fieldHelp(key: string): string | undefined {
       }}
     </div>
 
-    <!-- Backend selector: the BYO manifest backend or a native Kubernetes backend. -->
-    <UFormField v-if="showBackendSelector" :label="backendSelectorLabel">
-      <USelect v-model="backendKind" :items="backendKindItems" />
+    <!-- Backend selector: the BYO manifest backend, a native Kubernetes backend, or a
+         programmatically-registered custom kind. -->
+    <UFormField :label="backendSelectorLabel">
+      <USelect
+        v-model="backendKind"
+        :items="backendKindItems"
+        @update:model-value="onBackendKindChange(String($event))"
+      />
     </UFormField>
 
     <!-- Native Kubernetes runner backend (runner-pool). -->

package/app/components/testing/TestReportWindow.vue

@@ -23,7 +23,7 @@ import ProvisioningLogsDrawer from '~/components/provisioning/ProvisioningLogsDr
 
 const board = useBoardStore()
 const execution = useExecutionStore()
-const { t, d } = useI18n()
+const { t, d, n } = useI18n()
 
 // Per-window blob cache for the captured screenshots; revoked on unmount.
 const blobs = useArtifactBlobs()
@@ -58,6 +58,14 @@ const executionId = computed(() => instance.value?.id ?? null)
 // The infra-attempts log drawer is opened on demand (it fetches the per-run log rows).
 const showProvisioning = ref(false)
 
+// The in-container docker-compose dependency stand-up record (local-infra tester): whether
+// the dependencies came up + the captured `docker compose up` logs. Unlike the provisioning
+// drawer above (the orchestrator-side container/env spin-up), this is the stand-up that runs
+// INSIDE the container — the highest-signal artifact when local infra fails to come up.
+const infraSetup = computed(() => testState.value?.infraSetup ?? null)
+// The captured stand-up logs are shown on demand (they can be long).
+const showInfraSetupLogs = ref(false)
+
 const screenshots = computed<TestScreenshot[]>(() => report.value?.screenshots ?? [])
 // Resolve each capture into an object URL for the gallery + lightbox. The shared cache
 // dedupes, so the lightbox reuses what the thumbnails fetched. (The reference design is not
@@ -338,7 +346,7 @@ const GROUP_STATUS_META: Record<ScenarioGroup['status'], { icon: string; text: s
                  environment. A no-infra tester (no container, no env) has no infra attempts
                  either, so we don't render an empty header + a log toggle over nothing. -->
             <section
-              v-if="step && (step.container || stepEnvironment)"
+              v-if="step && (step.container || stepEnvironment || infraSetup)"
               data-testid="tester-infrastructure"
               class="space-y-3"
             >
@@ -347,6 +355,75 @@ const GROUP_STATUS_META: Record<ScenarioGroup['status'], { icon: string; text: s
               </h3>
               <StepContainerStatus :step="step" :run-failed="runFailed" />
               <EnvironmentStatusPanel v-if="stepEnvironment" :environment="stepEnvironment" />
+
+              <!-- In-container docker-compose dependency stand-up (local-infra tester): the
+                   outcome + the captured `docker compose up` logs. This is the stand-up that
+                   runs INSIDE the container, so its output isn't in the provisioning drawer
+                   below — it's the highest-signal artifact when local infra fails to start. -->
+              <div
+                v-if="infraSetup"
+                data-testid="tester-infra-setup"
+                class="rounded-lg border px-3 py-2"
+                :class="
+                  infraSetup.started
+                    ? 'border-slate-800 bg-slate-900/60'
+                    : 'border-rose-500/40 bg-rose-500/10'
+                "
+              >
+                <div class="flex items-center gap-2">
+                  <UIcon
+                    :name="infraSetup.started ? 'i-lucide-container' : 'i-lucide-circle-x'"
+                    class="h-3.5 w-3.5 shrink-0"
+                    :class="infraSetup.started ? 'text-emerald-400' : 'text-rose-400'"
+                  />
+                  <span class="text-[13px] font-medium text-slate-200">
+                    {{ infraSetup.started ? t('testing.standup.up') : t('testing.standup.failed') }}
+                  </span>
+                  <span
+                    v-if="infraSetup.durationMs != null"
+                    class="ml-auto text-[11px] text-slate-500"
+                  >
+                    {{
+                      t('testing.standup.took', {
+                        seconds: n(infraSetup.durationMs / 1000, 'decimal'),
+                      })
+                    }}
+                  </span>
+                </div>
+                <p v-if="infraSetup.composePath" class="mt-1 font-mono text-[11px] text-slate-500">
+                  {{ infraSetup.composePath }}
+                </p>
+                <p
+                  v-if="infraSetup.error"
+                  class="mt-1 text-[12px] leading-snug text-rose-300"
+                  data-testid="tester-infra-setup-error"
+                >
+                  {{ infraSetup.error }}
+                </p>
+                <template v-if="infraSetup.logs">
+                  <UButton
+                    :icon="showInfraSetupLogs ? 'i-lucide-chevron-up' : 'i-lucide-scroll-text'"
+                    variant="ghost"
+                    size="xs"
+                    class="mt-1.5"
+                    data-testid="tester-infra-setup-logs-toggle"
+                    @click="showInfraSetupLogs = !showInfraSetupLogs"
+                  >
+                    {{
+                      showInfraSetupLogs
+                        ? t('testing.standup.hideLogs')
+                        : t('testing.standup.showLogs')
+                    }}
+                  </UButton>
+                  <pre
+                    v-if="showInfraSetupLogs"
+                    data-testid="tester-infra-setup-logs"
+                    class="mt-2 max-h-64 overflow-auto rounded bg-slate-950/70 p-2 font-mono text-[11px] leading-relaxed text-slate-300"
+                    >{{ infraSetup.logs }}</pre
+                  >
+                </template>
+              </div>
+
               <div v-if="executionId">
                 <UButton
                   :icon="showProvisioning ? 'i-lucide-chevron-up' : 'i-lucide-scroll-text'"

package/app/composables/api/providerConnections.ts

@@ -51,8 +51,20 @@ const CONTRACTS = {
 /** Environment-provider + runner-pool connection endpoints (self-describe + register/test). */
 export function providerConnectionsApi({ send, ws }: ApiContext) {
   return {
-    describeProvider: (workspaceId: string, kind: ProviderConnectionKind) =>
-      send(CONTRACTS[kind].describe, { pathPrefix: ws(workspaceId) }),
+    // `backendKind` (optional) describes a REGISTERED backend that isn't connected yet, so a
+    // custom kind's connect form renders before the first connect. Omitted ⇒ the stored kind.
+    // Branch on the kind so `send` sees a single concrete contract (a union contract can't
+    // type-check the optional `queryParams`).
+    describeProvider: (workspaceId: string, kind: ProviderConnectionKind, backendKind?: string) =>
+      kind === 'environment'
+        ? send(CONTRACTS.environment.describe, {
+            pathPrefix: ws(workspaceId),
+            queryParams: { kind: backendKind },
+          })
+        : send(CONTRACTS['runner-pool'].describe, {
+            pathPrefix: ws(workspaceId),
+            queryParams: { kind: backendKind },
+          }),
 
     getProviderConnection: (workspaceId: string, kind: ProviderConnectionKind) =>
       send(CONTRACTS[kind].get, { pathPrefix: ws(workspaceId) }),
@@ -118,10 +130,11 @@ export function providerConnectionsApi({ send, ws }: ApiContext) {
 /**
  * Resolve the discriminated backend config (runner-pool OR environment) from a connect-form
  * payload: an explicit `config` (the Kubernetes form) wins; otherwise a bare `manifest` (the
- * manifest editor) is wrapped into the `manifest` backend kind. Both subsystems now take a
- * discriminated `config`, so the same shape serves each.
+ * flat form / manifest editor) is wrapped into the selected backend kind — `body.backendKind`
+ * (a built-in `manifest` or a registered CUSTOM slug), defaulting to `manifest`. A custom kind
+ * MUST carry its slug here, else its flat-form save would be mis-tagged as the manifest backend.
  */
 function backendConfig(body: RegisterProviderInput | TestProviderInput): Record<string, unknown> {
   if (body.config) return body.config
-  return { kind: 'manifest', manifest: body.manifest ?? {} }
+  return { kind: body.backendKind ?? 'manifest', manifest: body.manifest ?? {} }
 }

package/app/stores/providerConnections.ts

@@ -1,5 +1,6 @@
 import { defineStore } from 'pinia'
 import { computed, reactive, ref } from 'vue'
+import type { BackendKindOption } from '@cat-factory/contracts'
 import type {
   ProviderConnection,
   ProviderConnectionKind,
@@ -11,6 +12,21 @@ import { useWorkspaceStore } from '~/stores/workspace'
 
 const KINDS: ProviderConnectionKind[] = ['environment', 'runner-pool']
 
+// Built-in fallback so the connect form's backend selector works before the snapshot
+// loads (or on an older backend that doesn't advertise the kinds). The live lists come
+// from the workspace snapshot (`environmentBackendKinds` / `runnerBackendKinds`) and may
+// additionally carry a deployment's programmatically-registered CUSTOM kinds.
+const BUILTIN_BACKEND_KINDS: Record<ProviderConnectionKind, BackendKindOption[]> = {
+  environment: [
+    { kind: 'manifest', label: 'HTTP manifest' },
+    { kind: 'kubernetes', label: 'Kubernetes' },
+  ],
+  'runner-pool': [
+    { kind: 'manifest', label: 'HTTP manifest pool' },
+    { kind: 'kubernetes', label: 'Kubernetes' },
+  ],
+}
+
 interface ProviderState {
   /** null until first probed; false ⇒ integration disabled on the backend (hide it). */
   available: boolean | null
@@ -38,13 +54,35 @@ export const useProviderConnectionsStore = defineStore('providerConnections', ()
   })
   const loaded = ref(false)
   let inFlight: Promise<void> | null = null
+  // The selectable backend kinds per subsystem, fed from the workspace snapshot.
+  const backendKinds = reactive<Record<ProviderConnectionKind, BackendKindOption[]>>({
+    environment: BUILTIN_BACKEND_KINDS.environment,
+    'runner-pool': BUILTIN_BACKEND_KINDS['runner-pool'],
+  })
+
+  /** Seed the backend-kind selector lists from the workspace snapshot (built-in + custom). */
+  function registerBackendKinds(
+    payload: Partial<Record<ProviderConnectionKind, BackendKindOption[]>>,
+  ) {
+    for (const kind of KINDS) {
+      const list = payload[kind]
+      if (list && list.length > 0) backendKinds[kind] = list
+    }
+  }
+
+  /** The selectable backend kinds for a subsystem (built-in fallback until the snapshot loads). */
+  function backendKindsFor(kind: ProviderConnectionKind): BackendKindOption[] {
+    return backendKinds[kind]
+  }
 
-  async function loadKind(kind: ProviderConnectionKind) {
+  // `backendKind` (optional) re-probes the descriptor for a specific (e.g. not-yet-connected
+  // custom) backend kind, so its connect form renders before the first connect.
+  async function loadKind(kind: ProviderConnectionKind, backendKind?: string) {
     const ws = useWorkspaceStore()
     const s = state[kind]
     try {
       const [descriptor, { connection }] = await Promise.all([
-        api.describeProvider(ws.requireId(), kind),
+        api.describeProvider(ws.requireId(), kind, backendKind),
         api.getProviderConnection(ws.requireId(), kind),
       ])
       s.descriptor = descriptor
@@ -58,9 +96,24 @@ export const useProviderConnectionsStore = defineStore('providerConnections', ()
     }
   }
 
+  /**
+   * Re-probe ONLY the descriptor for a specific backend kind (e.g. a not-yet-connected
+   * custom kind the user just picked), leaving the stored connection untouched. Switching
+   * the selector must NOT re-fetch the connection: that would reassign `state.connection`
+   * and bounce the selector back to the stored kind via the component's `connection` watch.
+   */
+  async function loadDescriptor(kind: ProviderConnectionKind, backendKind?: string) {
+    const ws = useWorkspaceStore()
+    try {
+      state[kind].descriptor = await api.describeProvider(ws.requireId(), kind, backendKind)
+    } catch {
+      // Keep the existing descriptor/availability on a transient describe failure.
+    }
+  }
+
   /** Refresh both providers (used by the banner + after a save/remove). */
   async function load() {
-    await Promise.all(KINDS.map(loadKind))
+    await Promise.all(KINDS.map((k) => loadKind(k)))
     loaded.value = true
   }
 
@@ -123,11 +176,14 @@ export const useProviderConnectionsStore = defineStore('providerConnections', ()
     loaded,
     load,
     loadKind,
+    loadDescriptor,
     ensureLoaded,
     descriptorFor,
     connectionFor,
     isAvailable,
     needingConfig,
+    backendKindsFor,
+    registerBackendKinds,
     register,
     updateSecrets,
     test,

package/app/stores/workspace.ts

@@ -21,6 +21,7 @@ import { useClarityStore } from '~/stores/clarity'
 import { useBrainstormStore } from '~/stores/brainstorm'
 import { useConsensusStore } from '~/stores/consensus'
 import { useGitHubStore } from '~/stores/github'
+import { useProviderConnectionsStore } from '~/stores/providerConnections'
 
 /**
  * Owns the active workspace and bootstraps the app against the backend. On load
@@ -98,6 +99,13 @@ export const useWorkspaceStore = defineStore(
       // Merge the deployment's registered custom agent kinds into the palette catalog so a
       // proprietary kind renders as a first-class block + result view (idempotent on reload).
       useAgentsStore().registerCustomKinds(snapshot.customAgentKinds ?? [])
+      // Seed the connect form's backend-kind selectors (built-in + any custom backend a
+      // deployment registered), so a programmatically-registered env/runner backend is a
+      // first-class connect option instead of a hardcoded manifest/kubernetes list.
+      useProviderConnectionsStore().registerBackendKinds({
+        environment: snapshot.environmentBackendKinds,
+        'runner-pool': snapshot.runnerBackendKinds,
+      })
     }
 
     /** Resolve accounts + boards, then open the right board for the active account. */

package/app/types/providerConnections.ts

@@ -50,8 +50,14 @@ export interface ProviderConnection {
  */
 export interface RegisterProviderInput {
   manifest?: Record<string, unknown>
-  /** The discriminated runner-backend config (manifest pool or kubernetes). */
+  /** The discriminated runner-backend config (manifest pool, kubernetes, or a custom kind). */
   config?: Record<string, unknown>
+  /**
+   * The selected backend kind, used to wrap a bare `manifest` into the discriminated config
+   * (`{ kind, manifest }`). Defaults to `manifest`. A CUSTOM registered kind passes its slug
+   * here so the flat-form save isn't mis-tagged as the built-in manifest backend.
+   */
+  backendKind?: string
   secrets: Record<string, string>
 }
 
@@ -59,5 +65,6 @@ export interface RegisterProviderInput {
 export interface TestProviderInput {
   manifest?: Record<string, unknown>
   config?: Record<string, unknown>
+  backendKind?: string
   secrets?: Record<string, string>
 }

package/i18n/locales/en.json

@@ -2999,6 +2999,13 @@
     },
     "environment": "Environment",
     "infrastructure": "Infrastructure",
+    "standup": {
+      "up": "Dependencies started",
+      "failed": "Dependencies failed to start",
+      "took": "Took {seconds}s",
+      "showLogs": "Show stand-up logs",
+      "hideLogs": "Hide stand-up logs"
+    },
     "footer": "Scenarios are the areas the Tester chose to exercise (its spec acceptance scenarios). Outcomes and concerns are grouped under them by name.",
     "@screenshotAlt": {
       "description": "Alt text for a captured screenshot thumbnail; {view} is the screen/view name. The literal word 'screenshot' should be localized."

package/i18n/locales/es.json

@@ -2912,7 +2912,14 @@
     },
     "environment": "Entorno",
     "footer": "Los escenarios son las áreas que el Tester decidió ejercitar (sus escenarios de aceptación de la especificación). Los resultados y las incidencias se agrupan bajo ellos por nombre.",
-    "infrastructure": "Infraestructura"
+    "infrastructure": "Infraestructura",
+    "standup": {
+      "up": "Dependencias iniciadas",
+      "failed": "No se pudieron iniciar las dependencias",
+      "took": "Tardó {seconds}s",
+      "showLogs": "Mostrar registros de arranque",
+      "hideLogs": "Ocultar registros de arranque"
+    }
   },
   "visualConfirm": {
     "ariaLabel": "Confirmación visual",

package/i18n/locales/fr.json

@@ -2912,7 +2912,14 @@
     },
     "environment": "Environnement",
     "footer": "Les scénarios sont les domaines que le Testeur a choisi d'éprouver (ses scénarios d'acceptation de la spécification). Les résultats et les réserves y sont regroupés par nom.",
-    "infrastructure": "Infrastructure"
+    "infrastructure": "Infrastructure",
+    "standup": {
+      "up": "Dépendances démarrées",
+      "failed": "Échec du démarrage des dépendances",
+      "took": "Durée : {seconds}s",
+      "showLogs": "Afficher les journaux de démarrage",
+      "hideLogs": "Masquer les journaux de démarrage"
+    }
   },
   "visualConfirm": {
     "ariaLabel": "Confirmation visuelle",

package/i18n/locales/pl.json

@@ -2912,7 +2912,14 @@
     },
     "environment": "Środowisko",
     "footer": "Scenariusze to obszary, które Tester postanowił sprawdzić (jego scenariusze akceptacyjne ze specyfikacji). Wyniki i zastrzeżenia są pod nimi grupowane według nazwy.",
-    "infrastructure": "Infrastruktura"
+    "infrastructure": "Infrastruktura",
+    "standup": {
+      "up": "Zależności uruchomione",
+      "failed": "Nie udało się uruchomić zależności",
+      "took": "Czas: {seconds}s",
+      "showLogs": "Pokaż dzienniki uruchamiania",
+      "hideLogs": "Ukryj dzienniki uruchamiania"
+    }
   },
   "visualConfirm": {
     "ariaLabel": "Potwierdzenie wizualne",

package/i18n/locales/uk.json

@@ -2912,7 +2912,14 @@
     },
     "environment": "Середовище",
     "footer": "Сценарії — це області, які Тестувальник вирішив перевірити (його сценарії приймання зі специфікації). Результати та зауваження групуються під ними за назвою.",
-    "infrastructure": "Інфраструктура"
+    "infrastructure": "Інфраструктура",
+    "standup": {
+      "up": "Залежності запущено",
+      "failed": "Не вдалося запустити залежності",
+      "took": "Час: {seconds}s",
+      "showLogs": "Показати журнали запуску",
+      "hideLogs": "Сховати журнали запуску"
+    }
   },
   "visualConfirm": {
     "ariaLabel": "Візуальне підтвердження",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.51.1",
+  "version": "0.53.0",
   "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",
@@ -34,7 +34,7 @@
     "valibot": "^1.4.2",
     "vue": "^3.5.39",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.53.0"
+    "@cat-factory/contracts": "0.55.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",