@cat-factory/app 0.208.1 → 0.209.0

package/app/components/settings/CapabilityCredentialsPanel.vue

@@ -0,0 +1,262 @@
+<script setup lang="ts">
+// Capability credentials — the sealed, per-workspace values behind the secrets a registered tool
+// server (MCP) or generative binary integration declares BY NAME. It renders as a CHECKLIST, not
+// a blank key-value form: which keys exist is a property of the deployment's CODE, so the panel
+// projects the declarations and the operator fills them in. A blank form would mean reading the
+// deployment's source to learn what to type, with a typo producing a sealed row nothing asks for.
+//
+// Values are write-only and saved ONE KEY AT A TIME. The whole-set write is unusable here: this
+// client never receives the values, so replacing the set would delete every credential the
+// operator did not retype in this sitting.
+//
+// Renders inside the Infrastructure window's "Capability credentials" tab: what an agent's tools
+// authenticate as is part of where agents RUN. `secrets.manage`-gated end to end (the READ
+// included — the view names the deployment's credential keys), so the tab is HIDDEN, never
+// disabled, for anyone without it.
+import { computed, onMounted, reactive, ref } from 'vue'
+import type { CapabilityCredentialStatus } from '~/types/capabilityCredentials'
+import SecretInput from '~/components/common/SecretInput.vue'
+
+const { t, d } = useI18n()
+const store = useCapabilityCredentialsStore()
+const toast = useToast()
+const { confirmAction, toastDone } = useConfirmAction()
+
+// Which declaring capability wants a key. An exhaustive Record over the wire union, so a new
+// subject fails to compile until it has translated copy — the sanctioned guard for an enum-keyed
+// lookup the typed-message-key check cannot see.
+type CredentialSubject = CapabilityCredentialStatus['declaredBy'][number]['subject']
+const SUBJECT_LABELS = computed<Record<CredentialSubject, string>>(() => ({
+  'tool-server': t('settings.capabilityCredentials.subject.toolServer'),
+  'binary-generator': t('settings.capabilityCredentials.subject.binaryGenerator'),
+}))
+
+// Draft values, keyed by credential key. Never prefilled: nothing here was ever read back, and a
+// masked placeholder standing in for a stored value would make "unchanged" and "retyped" look
+// identical at the save button.
+const drafts = reactive<Record<string, string>>({})
+// Which row's WHICH button is in flight. The action is part of the state because save and delete
+// sit beside each other on one row: a shared per-key flag would spin the delete button for the
+// save the user just clicked, which reads as a delete in progress.
+const busy = ref<{ key: string; action: 'save' | 'remove' } | null>(null)
+// Failures present through the shared status-class funnel (translated description up front, the
+// raw backend prose + requestId behind "Show details"), never raw `e.message` as the description.
+const { present } = usePipelineErrorToast()
+
+const view = computed(() => store.view)
+
+function isBusy(key: string, action: 'save' | 'remove') {
+  return busy.value?.key === key && busy.value.action === action
+}
+
+// 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 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, so reopening the tab after the
+// deployment registered a new capability shows the new key.
+onMounted(async () => {
+  try {
+    await store.load()
+  } catch (e) {
+    present(e, 'settings.capabilityCredentials.toast.loadFailed')
+  }
+})
+
+async function saveKey(key: string) {
+  const value = (drafts[key] ?? '').trim()
+  if (!value) return
+  busy.value = { key, action: 'save' }
+  try {
+    await store.save(key, value)
+    drafts[key] = ''
+    toast.add({
+      title: t('settings.capabilityCredentials.toast.saved', { key }),
+      icon: 'i-lucide-check',
+      color: 'success',
+    })
+  } catch (e) {
+    present(e, 'settings.capabilityCredentials.toast.saveFailed')
+  } finally {
+    busy.value = null
+  }
+}
+
+async function removeKey(key: string) {
+  const noun = t('settings.capabilityCredentials.credentialNoun', { key })
+  if (!(await confirmAction('remove', noun))) return
+  busy.value = { key, action: 'remove' }
+  try {
+    await store.remove(key)
+    toastDone('remove', noun)
+  } catch (e) {
+    present(e, 'settings.capabilityCredentials.toast.removeFailed')
+  } finally {
+    busy.value = null
+  }
+}
+</script>
+
+<template>
+  <div class="space-y-4" data-testid="capability-credentials-panel">
+    <p class="text-sm text-slate-400">
+      {{ t('settings.capabilityCredentials.intro') }}
+    </p>
+
+    <!-- The declaration read failed (the deployment's generative integrations could not be
+         reached), so this checklist may be SHORT and the orphan list is withheld. Said out loud
+         rather than rendered as a clean empty list: an outage and "nothing needs a credential"
+         are the same list and opposite facts. -->
+    <UAlert
+      v-if="view?.declarationsIncomplete"
+      color="warning"
+      variant="subtle"
+      icon="i-lucide-triangle-alert"
+      :title="t('settings.capabilityCredentials.incomplete.title')"
+      :description="t('settings.capabilityCredentials.incomplete.body')"
+      data-testid="capability-credentials-incomplete"
+    />
+
+    <section
+      v-for="entry in view?.declared ?? []"
+      :key="entry.key"
+      class="space-y-3 rounded-lg border border-slate-700 p-3"
+      :data-testid="`capability-credential-${entry.key}`"
+    >
+      <div class="flex flex-wrap items-center gap-2">
+        <code class="font-mono text-sm font-medium">{{ entry.key }}</code>
+        <UBadge v-if="entry.required" color="warning" variant="soft" size="sm">
+          {{ t('settings.capabilityCredentials.required') }}
+        </UBadge>
+        <UBadge v-else color="neutral" variant="soft" size="sm">
+          {{ t('settings.capabilityCredentials.optional') }}
+        </UBadge>
+        <UBadge
+          v-if="entry.stored"
+          color="success"
+          variant="soft"
+          size="sm"
+          :data-testid="`capability-credential-stored-${entry.key}`"
+        >
+          {{ t('settings.capabilityCredentials.stored') }}
+        </UBadge>
+      </div>
+
+      <!-- Who wants the value, so an operator can tell what they are about to change. One key is
+           routinely wanted by more than one capability (two integrations behind one vendor
+           account), which is exactly when a rotation has consequences beyond the row it edits. -->
+      <ul class="space-y-1 text-xs text-slate-400">
+        <li v-for="declarer in entry.declaredBy" :key="`${declarer.subject}:${declarer.id}`">
+          <span class="text-slate-300">{{ declarer.label }}</span>
+          <span class="text-slate-500"> · {{ SUBJECT_LABELS[declarer.subject] }}</span>
+          <span v-if="declarer.usage" class="block text-slate-500">{{ declarer.usage }}</span>
+        </li>
+      </ul>
+
+      <p v-if="entry.stored && entry.updatedAt" class="text-[11px] text-slate-500">
+        {{
+          t('settings.capabilityCredentials.storedAt', {
+            date: d(new Date(entry.updatedAt), 'short'),
+          })
+        }}
+      </p>
+      <!-- An EMPTY row is not the same fact in both deployments, so it must not read the same
+           way. Behind the store the deployment's own environment may still answer for this key,
+           and calling that "missing" would send an operator hunting for a value that is already
+           resolving. -->
+      <p v-else-if="view?.environmentFallback" class="text-[11px] text-slate-500">
+        {{ t('settings.capabilityCredentials.notStoredWithFallback') }}
+      </p>
+      <p v-else class="text-[11px] text-amber-400">
+        {{ t('settings.capabilityCredentials.notStored') }}
+      </p>
+
+      <div class="flex items-end gap-2">
+        <UFormField
+          class="flex-1"
+          :label="
+            entry.stored
+              ? t('settings.capabilityCredentials.replaceValue')
+              : t('settings.capabilityCredentials.setValue')
+          "
+        >
+          <SecretInput
+            v-model="drafts[entry.key]"
+            class="w-full"
+            :data-testid="`capability-credential-input-${entry.key}`"
+            @keyup.enter="saveKey(entry.key)"
+          />
+        </UFormField>
+        <UButton
+          :loading="isBusy(entry.key, 'save')"
+          :disabled="!(drafts[entry.key] ?? '').trim() || isBusy(entry.key, 'remove')"
+          :data-testid="`capability-credential-save-${entry.key}`"
+          @click="saveKey(entry.key)"
+        >
+          {{ t('settings.capabilityCredentials.save') }}
+        </UButton>
+        <UButton
+          v-if="entry.stored"
+          color="error"
+          variant="ghost"
+          icon="i-lucide-trash-2"
+          :loading="isBusy(entry.key, 'remove')"
+          :disabled="isBusy(entry.key, 'save')"
+          :data-testid="`capability-credential-delete-${entry.key}`"
+          :aria-label="t('settings.capabilityCredentials.remove')"
+          @click="removeKey(entry.key)"
+        />
+      </div>
+    </section>
+
+    <p
+      v-if="view && !view.declared.length && !view.declarationsIncomplete"
+      class="text-sm text-slate-500"
+    >
+      {{ t('settings.capabilityCredentials.noneDeclared') }}
+    </p>
+
+    <!-- Stored keys nothing declares any more: a live secret nobody will ever ask for, which is
+         what a retired integration or a renamed variable leaves behind. Listed rather than
+         filtered, because only the operator can tell "delete this" from "the deployment
+         regressed". Withheld entirely while the declaration read is incomplete. -->
+    <section
+      v-if="view?.orphaned.length"
+      class="space-y-2 rounded-lg border border-amber-900/60 p-3"
+      data-testid="capability-credentials-orphaned"
+    >
+      <h3 class="text-sm font-semibold">
+        {{ t('settings.capabilityCredentials.orphaned.heading') }}
+      </h3>
+      <p class="text-xs text-slate-400">
+        {{ t('settings.capabilityCredentials.orphaned.body') }}
+      </p>
+      <div
+        v-for="orphan in view.orphaned"
+        :key="orphan.key"
+        class="flex items-center justify-between gap-2 rounded-md border border-slate-800 px-3 py-2"
+      >
+        <div class="min-w-0">
+          <code class="font-mono text-sm">{{ orphan.key }}</code>
+          <span class="block text-[11px] text-slate-500">
+            {{
+              t('settings.capabilityCredentials.storedAt', {
+                date: d(new Date(orphan.updatedAt), 'short'),
+              })
+            }}
+          </span>
+        </div>
+        <UButton
+          color="error"
+          variant="ghost"
+          icon="i-lucide-trash-2"
+          size="sm"
+          :loading="isBusy(orphan.key, 'remove')"
+          :data-testid="`capability-credential-delete-${orphan.key}`"
+          :aria-label="t('settings.capabilityCredentials.remove')"
+          @click="removeKey(orphan.key)"
+        />
+      </div>
+    </section>
+  </div>
+</template>

package/app/components/settings/InfrastructureWindow.logic.spec.ts

@@ -5,7 +5,12 @@ import {
   repinInfrastructureTab,
 } from './InfrastructureWindow.logic'
 
-const NONE = { agents: false, environments: false, packageRegistries: false }
+const NONE = {
+  agents: false,
+  environments: false,
+  packageRegistries: false,
+  capabilityCredentials: false,
+}
 
 describe('infrastructureTabs', () => {
   it('shows nothing when no probe reports a backend', () => {
@@ -28,10 +33,30 @@ describe('infrastructureTabs', () => {
     expect(infrastructureTabs({ ...NONE, agents: true })).toEqual(['runner-pool'])
   })
 
+  it('gates the capability-credentials tab on its own two-part probe', () => {
+    // Unlike its neighbours this one also gates on CONTENT: the panel is a checklist projected
+    // from the deployment's registered capabilities, so a build that registers none has no
+    // credential to type. The window folds that (and the `secrets.manage` check) into the flag.
+    expect(infrastructureTabs({ ...NONE, capabilityCredentials: true })).toEqual([
+      'capability-credentials',
+    ])
+  })
+
   it('orders tabs by the question they answer, not by which probe resolved', () => {
     expect(
-      infrastructureTabs({ agents: true, environments: true, packageRegistries: true }),
-    ).toEqual(['runner-pool', 'environment', 'shared-stacks', 'package-registries'])
+      infrastructureTabs({
+        agents: true,
+        environments: true,
+        packageRegistries: true,
+        capabilityCredentials: true,
+      }),
+    ).toEqual([
+      'runner-pool',
+      'environment',
+      'shared-stacks',
+      'package-registries',
+      'capability-credentials',
+    ])
   })
 })
 

package/app/components/settings/InfrastructureWindow.logic.ts

@@ -19,12 +19,25 @@ export interface InfrastructureTabAvailability {
   environments: boolean
   /** The package-registries module answered its probe affirmatively (it 503s unconfigured). */
   packageRegistries: boolean
+  /**
+   * The capability-credential surface has something to show: its probe resolved (the module 503s
+   * with no encryption key, and 403s for a caller without `secrets.manage`) AND this deployment's
+   * registered capabilities declare a credential, or the workspace stored one nothing declares,
+   * or the declaration read failed.
+   *
+   * Unlike every other tab this one gates on CONTENT as well as availability, because the panel
+   * is a CHECKLIST projected from the deployment's code: a build that registers no tool server
+   * and no generative integration has no credential to type, so the tab would be a dead end. The
+   * failed-read case is deliberately kept IN — an unreadable list and an empty one are the same
+   * list and opposite facts, and only the panel can say which one this is.
+   */
+  capabilityCredentials: boolean
 }
 
 /**
  * The window's tabs, in display order. Order is the reading order of the questions they answer:
  * where agent containers run, where test environments run, what those environments attach to,
- * and what a checkout may install from.
+ * what a checkout may install from, and what the tools an agent reaches authenticate as.
  *
  * Shared stacks ride the test-environment probe because a stack is infra an environment attaches
  * to — there is nothing to attach without an environment backend.
@@ -34,6 +47,7 @@ export function infrastructureTabs(available: InfrastructureTabAvailability): In
   if (available.agents) tabs.push('runner-pool')
   if (available.environments) tabs.push('environment', 'shared-stacks')
   if (available.packageRegistries) tabs.push('package-registries')
+  if (available.capabilityCredentials) tabs.push('capability-credentials')
   return tabs
 }
 

package/app/components/settings/InfrastructureWindow.vue

@@ -15,6 +15,10 @@
 //   - "Package registries" — the private npm registries a checkout installs from (formerly an
 //     Integrations-hub row). What a container can resolve its dependencies from is part of the
 //     execution environment, not an optional external system a workspace links in.
+//   - "Capability credentials" — the sealed per-workspace values behind the secrets a registered
+//     tool server (MCP) or generative binary integration declares. What an agent's tools
+//     authenticate as belongs beside where those agents run, and it is `secrets.manage`-only, so
+//     the tab is HIDDEN rather than disabled for anyone without that permission.
 // Local-specific affordances render inline, gated on `auth.localMode?.enabled`. A tab whose
 // backend integration is disabled (503) simply doesn't render.
 import { computed, ref, watch } from 'vue'
@@ -31,12 +35,15 @@ import LocalContainerPoolSettings from '~/components/settings/LocalContainerPool
 import SharedStacksPanel from '~/components/settings/SharedStacksPanel.vue'
 import ComposeEnvironmentSetupSection from '~/components/settings/ComposeEnvironmentSetupSection.vue'
 import PackageRegistriesPanel from '~/components/settings/PackageRegistriesPanel.vue'
+import CapabilityCredentialsPanel from '~/components/settings/CapabilityCredentialsPanel.vue'
 
 const { t } = useI18n()
 const ui = useUiStore()
 const store = useProviderConnectionsStore()
 const auth = useAuthStore()
 const packageRegistries = usePackageRegistriesStore()
+const capabilityCredentials = useCapabilityCredentialsStore()
+const { canManageSecrets } = useWorkspaceAccess()
 
 const open = computed({
   get: () => ui.infrastructureOpen,
@@ -63,12 +70,14 @@ const TAB_LABELS = computed<Record<InfrastructureTab, string>>(() => ({
   environment: t('settings.providerConnection.tabs.testEnvironments'),
   'shared-stacks': t('settings.sharedStacks.tab'),
   'package-registries': t('settings.packageRegistries.tab'),
+  'capability-credentials': t('settings.capabilityCredentials.tab'),
 }))
 const TAB_ICONS: Record<InfrastructureTab, string> = {
   'runner-pool': 'i-lucide-server-cog',
   environment: 'i-lucide-cloud',
   'shared-stacks': 'i-lucide-layers',
   'package-registries': 'i-lucide-package',
+  'capability-credentials': 'i-lucide-key-round',
 }
 
 // `slot` mirrors `value` — the template names one `<template #…>` per tab value.
@@ -79,6 +88,12 @@ const tabs = computed(() =>
     // The module's own probe (the backend 503s with no encryption key), same gate as the
     // Integrations-hub row this replaced — an unconfigured backend shows no dead tab.
     packageRegistries: packageRegistries.available === true,
+    // Two gates, and neither implies the other. `canManageSecrets` hides the tab from a member
+    // who may not manage secrets (the view NAMES the deployment's credential keys, which is why
+    // the backend gates the read too), and `hasSurface` hides a tab with nothing in it — the
+    // panel is a checklist projected from the deployment's registered capabilities, so a build
+    // that registers none has no credential to type.
+    capabilityCredentials: canManageSecrets.value && capabilityCredentials.hasSurface,
   }).map((value) => ({
     value,
     label: TAB_LABELS.value[value],
@@ -102,6 +117,11 @@ watch(
     // Swallowed here on purpose: the PANEL reports a load failure, and it can only do that
     // once the tab it lives in exists, so a probe failure has to leave the window itself alone.
     void packageRegistries.ensureLoaded().catch(() => {})
+    // Same split as the registries probe: swallowed here (a failed probe means no tab, and the
+    // window must still open), reported by the panel, which can only do that once its tab exists.
+    // Not probed at all without the permission — the backend would refuse it, and asking would
+    // put a 403 in every member's console on every open.
+    if (canManageSecrets.value) void capabilityCredentials.ensureLoaded().catch(() => {})
     activeTab.value = openInfrastructureTab(tabValues.value, ui.infrastructureTab)
   },
   { immediate: true },
@@ -176,6 +196,9 @@ watch([tabs, () => store.loaded], () => {
           <template #package-registries>
             <PackageRegistriesPanel />
           </template>
+          <template #capability-credentials>
+            <CapabilityCredentialsPanel />
+          </template>
         </UTabs>
 
         <p v-else class="px-1 py-6 text-center text-sm text-slate-500">

package/app/composables/api/capabilityCredentials.ts

@@ -0,0 +1,37 @@
+import {
+  deleteCapabilityCredentialContract,
+  getCapabilityCredentialsContract,
+  setCapabilityCredentialContract,
+} from '@cat-factory/contracts'
+import type { ApiContext } from './context'
+
+/**
+ * Per-workspace capability credentials (SEALED, write-only). The GET view returns what this
+ * deployment's registered capabilities DECLARE joined to what this workspace has stored, never a
+ * value. Writes are PER KEY: the whole-set PUT exists for an API caller declaring a whole set at
+ * once, and this client could not use it — it never received the other values, so a set-replacing
+ * write here would delete every credential the operator did not retype.
+ *
+ * `secrets.manage`-gated end to end, the READ included: the view carries the credential key names
+ * the deployment's capabilities want, which the workspace snapshot deliberately omits.
+ * See CapabilityCredentialsController.
+ */
+export function capabilityCredentialsApi({ send, ws }: ApiContext) {
+  return {
+    getCapabilityCredentials: (workspaceId: string) =>
+      send(getCapabilityCredentialsContract, { pathPrefix: ws(workspaceId) }),
+
+    setCapabilityCredential: (workspaceId: string, key: string, value: string) =>
+      send(setCapabilityCredentialContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { key },
+        body: { value },
+      }),
+
+    deleteCapabilityCredential: (workspaceId: string, key: string) =>
+      send(deleteCapabilityCredentialContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { key },
+      }),
+  }
+}

package/app/composables/useApi.ts

@@ -31,6 +31,7 @@ import { localSettingsApi } from './api/localSettings'
 import { modelsApi } from './api/models'
 import { notificationsApi } from './api/notifications'
 import { packageRegistriesApi } from './api/packageRegistries'
+import { capabilityCredentialsApi } from './api/capabilityCredentials'
 import { preflightsApi } from './api/preflights'
 import { presetsApi } from './api/presets'
 import { publicApiKeysApi } from './api/publicApiKeys'
@@ -151,6 +152,7 @@ export function useApi() {
     ...validationChecksApi(ctx),
     ...testSecretsApi(ctx),
     ...packageRegistriesApi(ctx),
+    ...capabilityCredentialsApi(ctx),
     ...previewApi(ctx),
     ...environmentsApi(ctx),
     ...recurringApi(ctx),

package/app/stores/capabilityCredentials.spec.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useCapabilityCredentialsStore } from '~/stores/capabilityCredentials'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { CapabilityCredentialsView } from '~/types/capabilityCredentials'
+
+/**
+ * Two behaviours carry this store, and both are about a list that is empty for more than one
+ * reason:
+ *
+ *   - the probe. A 503 ("no encryption key on this deployment") and a 403 ("you may not manage
+ *     secrets") are ANSWERS and resolve normally, hiding the tab; anything else propagates,
+ *     because the panel is the surface that can tell a reader the list could not be fetched.
+ *   - `hasSurface`. An empty checklist with a COMPLETE declaration read means this deployment
+ *     registers no capability that wants a credential, so there is nothing to type; the same
+ *     empty checklist with an INCOMPLETE read is an outage the panel has to state.
+ */
+function view(over: Partial<CapabilityCredentialsView> = {}): CapabilityCredentialsView {
+  return {
+    declared: [],
+    orphaned: [],
+    environmentFallback: true,
+    declarationsIncomplete: false,
+    ...over,
+  }
+}
+
+function declared(key: string, stored = false) {
+  return {
+    key,
+    declaredBy: [{ subject: 'tool-server' as const, id: 'srv', label: 'Search' }],
+    required: true,
+    stored,
+    ...(stored ? { updatedAt: 1000 } : {}),
+  }
+}
+
+describe('capabilityCredentials store', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('load stores the view and marks the surface available', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getCapabilityCredentials: () => Promise.resolve(view({ declared: [declared('SEARCH_KEY')] })),
+    }))
+
+    const store = useCapabilityCredentialsStore()
+    await store.load()
+
+    expect(store.available).toBe(true)
+    expect(store.hasSurface).toBe(true)
+    expect(store.loading).toBe(false)
+  })
+
+  it.each([503, 403])(
+    'a definitive %i latches the surface unavailable without throwing',
+    async (statusCode) => {
+      // 503: the deployment has no encryption key. 403: this caller may not manage secrets, and
+      // the READ is gated too, because the view names the credential keys the deployment wants.
+      // Both hide the tab rather than disabling it.
+      vi.stubGlobal('useApi', () => ({
+        getCapabilityCredentials: () => Promise.reject({ statusCode }),
+      }))
+
+      const store = useCapabilityCredentialsStore()
+      await expect(store.load()).resolves.toBeUndefined()
+
+      expect(store.available).toBe(false)
+      expect(store.view).toBeNull()
+      expect(store.hasSurface).toBe(false)
+    },
+  )
+
+  it('a transient failure propagates and leaves `available` null so the probe stays retryable', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getCapabilityCredentials: () => Promise.reject({ statusCode: 500 }),
+    }))
+
+    const store = useCapabilityCredentialsStore()
+    await expect(store.load()).rejects.toMatchObject({ statusCode: 500 })
+
+    expect(store.available).toBeNull()
+    expect(store.loading).toBe(false)
+  })
+
+  it('offers no surface when nothing is declared and nothing is stored', async () => {
+    vi.stubGlobal('useApi', () => ({ getCapabilityCredentials: () => Promise.resolve(view()) }))
+
+    const store = useCapabilityCredentialsStore()
+    await store.load()
+
+    // The panel is a checklist projected from the deployment's registered capabilities. With
+    // none, there is no credential to type and the tab would be a dead end.
+    expect(store.available).toBe(true)
+    expect(store.hasSurface).toBe(false)
+  })
+
+  it('keeps the surface when the declaration read failed, even with both lists empty', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getCapabilityCredentials: () => Promise.resolve(view({ declarationsIncomplete: true })),
+    }))
+
+    const store = useCapabilityCredentialsStore()
+    await store.load()
+
+    // An unreadable list and an empty one are the same list and opposite facts. Hiding the tab
+    // here would render someone else's outage as "this deployment needs no credentials".
+    expect(store.hasSurface).toBe(true)
+  })
+
+  it('keeps the surface for an orphan nothing declares any more', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getCapabilityCredentials: () =>
+        Promise.resolve(view({ orphaned: [{ key: 'OLD_KEY', updatedAt: 1000 }] })),
+    }))
+
+    const store = useCapabilityCredentialsStore()
+    await store.load()
+
+    // A live secret nobody will ever ask for. The tab is the only place it can be removed.
+    expect(store.hasSurface).toBe(true)
+  })
+
+  it('saves ONE key and adopts the returned view', async () => {
+    const calls: { key: string; value: string }[] = []
+    vi.stubGlobal('useApi', () => ({
+      getCapabilityCredentials: () => Promise.resolve(view({ declared: [declared('SEARCH_KEY')] })),
+      setCapabilityCredential: (_ws: string, key: string, value: string) => {
+        calls.push({ key, value })
+        return Promise.resolve(view({ declared: [declared('SEARCH_KEY', true)] }))
+      },
+    }))
+
+    const store = useCapabilityCredentialsStore()
+    await store.load()
+    await store.save('SEARCH_KEY', 'sk-live')
+
+    // Per KEY, never a set-replacing write: this client never received the other values, so a
+    // whole-set save would delete every credential the operator did not retype.
+    expect(calls).toEqual([{ key: 'SEARCH_KEY', value: 'sk-live' }])
+    expect(store.view?.declared[0]?.stored).toBe(true)
+  })
+
+  it('re-reads after a delete rather than patching the row out locally', async () => {
+    let stored = true
+    vi.stubGlobal('useApi', () => ({
+      getCapabilityCredentials: () =>
+        Promise.resolve(view({ declared: [declared('SEARCH_KEY', stored)] })),
+      deleteCapabilityCredential: () => {
+        stored = false
+        return Promise.resolve(undefined)
+      },
+    }))
+
+    const store = useCapabilityCredentialsStore()
+    await store.load()
+    await store.remove('SEARCH_KEY')
+
+    // The DELETE answers 204, and the declared half is deployment state this client does not
+    // own: a locally-patched row would drift from it the moment the deployment changed.
+    expect(store.view?.declared[0]?.stored).toBe(false)
+  })
+})

package/app/stores/capabilityCredentials.ts

@@ -0,0 +1,102 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { CapabilityCredentialsView } from '~/types/capabilityCredentials'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { apiErrorStatus } from '~/composables/api/errors'
+
+/**
+ * The workspace's capability credentials: the sealed, tenant-scoped values behind the secrets a
+ * registered tool server (MCP) or generative binary integration declares BY NAME. Values are
+ * write-only — the store only ever holds the view, which pairs the deployment's DECLARATIONS with
+ * which of them this workspace has stored. Loaded on demand (the Infrastructure window's
+ * "Capability credentials" tab, whose existence gates on the probe below), not from the snapshot.
+ *
+ * Writes are PER KEY. A whole-set write exists on the API for a caller declaring a set at once,
+ * and this store cannot use it: it never receives the values, so replacing the set would delete
+ * every credential the operator did not retype in this sitting.
+ */
+export const useCapabilityCredentialsStore = defineStore('capabilityCredentials', () => {
+  const api = useApi()
+
+  const view = ref<CapabilityCredentialsView | null>(null)
+  const loading = ref(false)
+  // Mirrors the backend's two definitive refusals: the module 503s with no encryption key, and
+  // the whole surface (the READ included) is `secrets.manage`-gated, so a member without it gets
+  // a 403. `null` until first probed, then `true`/`false`. Both answers hide the tab rather than
+  // disabling it — a member who cannot manage secrets has no business learning which environment
+  // variables the deployment's capabilities want, which is the very content of this view.
+  const available = ref<boolean | null>(null)
+  let inFlight: Promise<void> | null = null
+
+  /**
+   * Whether there is anything to show. The panel is a CHECKLIST projected from the deployment's
+   * registered capabilities, so with nothing declared, nothing orphaned and a complete read there
+   * is no credential to type and no tab worth rendering.
+   *
+   * `declarationsIncomplete` keeps the surface even when both lists are empty, because then the
+   * emptiness is an OUTAGE (`BinaryGeneratorSource` throws rather than answering an empty set)
+   * rather than an answer, and hiding the tab would render the outage as "this deployment needs
+   * no credentials".
+   */
+  const hasSurface = computed(
+    () =>
+      view.value !== null &&
+      (view.value.declared.length > 0 ||
+        view.value.orphaned.length > 0 ||
+        view.value.declarationsIncomplete),
+  )
+
+  /** Force a refresh of the view (used after a save/remove). */
+  async function load() {
+    const ws = useWorkspaceStore()
+    loading.value = true
+    try {
+      view.value = await api.getCapabilityCredentials(ws.requireId())
+      available.value = true
+    } catch (err) {
+      const status = apiErrorStatus(err)
+      if (status === 503 || status === 403) {
+        // Definitive answers, not failures: the module is unconfigured, or this caller may not
+        // manage secrets. Hide the entry point and stop probing; resolve normally.
+        available.value = false
+        view.value = null
+        return
+      }
+      // Any other failure (transient 5xx / network) leaves the state untouched: it must not hide
+      // an already-available panel nor cache a false "unavailable", and `available` stays `null`
+      // when never probed so `ensureLoaded` remains retryable. The error PROPAGATES, because the
+      // panel is the one surface that can tell a reader it is looking at a list we could not
+      // fetch — the PROBE caller swallows instead (a failed probe means no tab, not a broken
+      // window). Same split as the package-registries store.
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /** Load once and share the result (coalescing concurrent callers); `load()` refreshes. */
+  async function ensureLoaded() {
+    if (available.value !== null) return
+    if (!inFlight) inFlight = load().finally(() => (inFlight = null))
+    return inFlight
+  }
+
+  /** Store ONE credential's value, leaving every other stored key as it is. */
+  async function save(key: string, value: string) {
+    const ws = useWorkspaceStore()
+    view.value = await api.setCapabilityCredential(ws.requireId(), key, value)
+    available.value = true
+  }
+
+  /** Remove ONE stored credential (a rotated key, or an orphan nothing declares any more). */
+  async function remove(key: string) {
+    const ws = useWorkspaceStore()
+    await api.deleteCapabilityCredential(ws.requireId(), key)
+    // The DELETE answers 204, so the view is re-read rather than patched locally: the declared
+    // half is deployment state this client does not own, and a locally-patched row would drift
+    // from it the moment the deployment changed.
+    await load()
+  }
+
+  return { view, loading, available, hasSurface, load, ensureLoaded, save, remove }
+})

package/app/types/capabilityCredentials.ts

@@ -0,0 +1,12 @@
+// Per-workspace capability-credential shapes: the tenant-scoped home for the secrets a
+// registered tool server (MCP) or generative binary integration declares BY NAME. Values are
+// write-only — the view carries the keys the deployment DECLARES, which of them this workspace
+// has stored, and which stored keys nothing declares any more.
+//
+// All wire shapes are sourced from @cat-factory/contracts (single source of truth).
+
+export type {
+  CapabilityCredentialRef,
+  CapabilityCredentialStatus,
+  CapabilityCredentialsView,
+} from '@cat-factory/contracts'

package/app/types/providerConnections.ts

@@ -27,7 +27,11 @@ export type ProviderConnectionKind = 'environment' | 'runner-pool'
  * pointer could open the window but never land the user on the tab it meant. Every tab
  * `InfrastructureWindow.vue` can render must have a name here.
  */
-export type InfrastructureTab = ProviderConnectionKind | 'shared-stacks' | 'package-registries'
+export type InfrastructureTab =
+  | ProviderConnectionKind
+  | 'shared-stacks'
+  | 'package-registries'
+  | 'capability-credentials'
 
 /** A workspace's provider binding, as exposed to clients (never secret values). */
 export interface ProviderConnection {

package/i18n/locales/de.json

@@ -568,6 +568,40 @@
         "removeFailed": "Der Registry-Eintrag konnte nicht entfernt werden"
       }
     },
+    "capabilityCredentials": {
+      "tab": "Zugangsdaten für Fähigkeiten",
+      "intro": "Die Secrets, die die Tool-Server und generativen Integrationen dieser Installation namentlich anfordern. Werte gelten nur für dieses Board, werden verschlüsselt gespeichert und direkt an den Prozess des Agenten übergeben: Sie erscheinen weder in einem Prompt noch in einem Log. Werte lassen sich nur schreiben, nie auslesen, ein gespeicherter Wert wird also durch Eingabe eines neuen ersetzt.",
+      "credentialNoun": "Zugangsdaten {key}",
+      "required": "Erforderlich",
+      "optional": "Optional",
+      "stored": "Gespeichert",
+      "storedAt": "Zuletzt gesetzt am {date}",
+      "notStoredWithFallback": "Für dieses Board ist nichts gespeichert. Diese Installation liest den Schlüssel auch aus ihrer eigenen Umgebung, die Fähigkeit funktioniert also möglicherweise trotzdem.",
+      "notStored": "Für dieses Board ist nichts gespeichert, und diese Installation hat keinen Rückfallwert aus der Umgebung. Die Fähigkeit kann sich daher nicht authentifizieren.",
+      "setValue": "Wert",
+      "replaceValue": "Gespeicherten Wert ersetzen",
+      "save": "Speichern",
+      "remove": "Zugangsdaten entfernen",
+      "noneDeclared": "Keine der registrierten Fähigkeiten dieser Installation fordert Zugangsdaten an.",
+      "subject": {
+        "toolServer": "Tool-Server",
+        "binaryGenerator": "Generative Integration"
+      },
+      "incomplete": {
+        "title": "Diese Liste ist möglicherweise unvollständig",
+        "body": "Die generativen Integrationen konnten nicht gelesen werden, daher fehlen unten womöglich Zugangsdaten, die eine von ihnen anfordert. Gespeicherte Schlüssel, die niemand anfordert, bleiben ausgeblendet, bis die Liste wieder gelesen werden kann."
+      },
+      "orphaned": {
+        "heading": "Gespeichert, aber nicht angefordert",
+        "body": "Nichts, was diese Installation registriert hat, fordert diese Schlüssel an. Genau das hinterlässt eine abgeschaltete Integration oder eine umbenannte Variable. Sie bleiben verschlüsselt gespeichert, bis du sie entfernst."
+      },
+      "toast": {
+        "loadFailed": "Zugangsdaten für Fähigkeiten konnten nicht geladen werden",
+        "saved": "{key} gespeichert",
+        "saveFailed": "Die Zugangsdaten konnten nicht gespeichert werden",
+        "removeFailed": "Die Zugangsdaten konnten nicht entfernt werden"
+      }
+    },
     "apiTokens": {
       "title": "API-Zugriffstokens",
       "intro": "Erstelle Tokens, die externe Systeme der cat-factory-API vorlegen. Jedes Token authentifiziert sich als dieser Arbeitsbereich an den /api/v1-Endpunkten. Das Geheimnis wird nur einmal bei der Erstellung angezeigt und kann nicht wiederhergestellt werden. Speichere es daher sofort.",

package/i18n/locales/en.json

@@ -2941,6 +2941,40 @@
         "removeFailed": "Could not remove the registry entry"
       }
     },
+    "capabilityCredentials": {
+      "tab": "Capability credentials",
+      "intro": "The secrets this deployment's tool servers and generative integrations ask for by name. Values are stored for this board only, sealed at rest, and handed straight to the agent's process: they never reach a prompt or a log. Values are write-only, so a stored one is replaced by typing a new one and never read back.",
+      "credentialNoun": "{key} credential",
+      "required": "Required",
+      "optional": "Optional",
+      "stored": "Stored",
+      "storedAt": "Last set {date}",
+      "notStoredWithFallback": "Nothing stored for this board. This deployment also reads the key from its own environment, so the capability may still be working.",
+      "notStored": "Nothing stored for this board, and this deployment has no environment fallback, so the capability cannot authenticate.",
+      "setValue": "Value",
+      "replaceValue": "Replace the stored value",
+      "save": "Save",
+      "remove": "Remove credential",
+      "noneDeclared": "None of this deployment's registered capabilities asks for a credential.",
+      "subject": {
+        "toolServer": "Tool server",
+        "binaryGenerator": "Generative integration"
+      },
+      "incomplete": {
+        "title": "This list may be incomplete",
+        "body": "The generative integrations could not be read, so a credential one of them asks for may be missing below. Stored keys that nothing asks for stay hidden until the list can be read again."
+      },
+      "orphaned": {
+        "heading": "Stored but not asked for",
+        "body": "Nothing this deployment has registered asks for these keys, which is what a retired integration or a renamed variable leaves behind. They stay sealed until you remove them."
+      },
+      "toast": {
+        "loadFailed": "Could not load capability credentials",
+        "saved": "Saved {key}",
+        "saveFailed": "Could not save the credential",
+        "removeFailed": "Could not remove the credential"
+      }
+    },
     "apiTokens": {
       "title": "API access tokens",
       "intro": "Create tokens that external systems present to the cat-factory API. Each token authenticates as this workspace on the /api/v1 endpoints. The secret is shown only once, when you create it, and cannot be recovered, so store it right away.",

package/i18n/locales/es.json

@@ -2709,6 +2709,40 @@
         "removeFailed": "No se pudo eliminar la entrada del registro"
       }
     },
+    "capabilityCredentials": {
+      "tab": "Credenciales de capacidades",
+      "intro": "Los secretos que los servidores de herramientas y las integraciones generativas de esta instalación piden por nombre. Los valores se guardan solo para este tablero, cifrados en reposo, y se entregan directamente al proceso del agente: nunca llegan a un prompt ni a un registro. Los valores son de solo escritura, así que uno guardado se sustituye escribiendo otro y nunca se vuelve a leer.",
+      "credentialNoun": "credencial {key}",
+      "required": "Obligatoria",
+      "optional": "Opcional",
+      "stored": "Guardada",
+      "storedAt": "Definida por última vez el {date}",
+      "notStoredWithFallback": "No hay nada guardado para este tablero. Esta instalación también lee la clave de su propio entorno, así que la capacidad puede seguir funcionando.",
+      "notStored": "No hay nada guardado para este tablero y esta instalación no tiene respaldo en el entorno, así que la capacidad no puede autenticarse.",
+      "setValue": "Valor",
+      "replaceValue": "Sustituir el valor guardado",
+      "save": "Guardar",
+      "remove": "Quitar credencial",
+      "noneDeclared": "Ninguna de las capacidades registradas de esta instalación pide credenciales.",
+      "subject": {
+        "toolServer": "Servidor de herramientas",
+        "binaryGenerator": "Integración generativa"
+      },
+      "incomplete": {
+        "title": "Puede que esta lista esté incompleta",
+        "body": "No se pudieron leer las integraciones generativas, así que abajo puede faltar alguna credencial que una de ellas pida. Las claves guardadas que nadie pide quedan ocultas hasta que la lista se pueda leer de nuevo."
+      },
+      "orphaned": {
+        "heading": "Guardadas pero no solicitadas",
+        "body": "Nada de lo que esta instalación tiene registrado pide estas claves, que es lo que deja una integración retirada o una variable renombrada. Seguirán cifradas hasta que las quites."
+      },
+      "toast": {
+        "loadFailed": "No se pudieron cargar las credenciales de capacidades",
+        "saved": "{key} guardada",
+        "saveFailed": "No se pudo guardar la credencial",
+        "removeFailed": "No se pudo quitar la credencial"
+      }
+    },
     "apiTokens": {
       "title": "Tokens de acceso a la API",
       "intro": "Crea tokens que los sistemas externos presentan a la API de cat-factory. Cada token se autentica como este espacio de trabajo en los endpoints /api/v1. El secreto se muestra una sola vez, al crearlo, y no se puede recuperar, así que guárdalo de inmediato.",

package/i18n/locales/fr.json

@@ -2709,6 +2709,40 @@
         "removeFailed": "Impossible de supprimer l'entrée du registre"
       }
     },
+    "capabilityCredentials": {
+      "tab": "Identifiants des capacités",
+      "intro": "Les secrets que les serveurs d'outils et les intégrations génératives de ce déploiement réclament par leur nom. Les valeurs ne sont enregistrées que pour ce tableau, chiffrées au repos, et remises directement au processus de l'agent : elles n'apparaissent ni dans un prompt ni dans un journal. Les valeurs sont en écriture seule, une valeur enregistrée se remplace donc en en saisissant une nouvelle et n'est jamais relue.",
+      "credentialNoun": "l'identifiant {key}",
+      "required": "Obligatoire",
+      "optional": "Facultatif",
+      "stored": "Enregistré",
+      "storedAt": "Défini le {date}",
+      "notStoredWithFallback": "Rien n'est enregistré pour ce tableau. Ce déploiement lit aussi la clé dans son propre environnement, la capacité fonctionne donc peut-être encore.",
+      "notStored": "Rien n'est enregistré pour ce tableau et ce déploiement n'a pas de valeur de repli dans l'environnement : la capacité ne peut pas s'authentifier.",
+      "setValue": "Valeur",
+      "replaceValue": "Remplacer la valeur enregistrée",
+      "save": "Enregistrer",
+      "remove": "Supprimer l'identifiant",
+      "noneDeclared": "Aucune des capacités enregistrées de ce déploiement ne réclame d'identifiant.",
+      "subject": {
+        "toolServer": "Serveur d'outils",
+        "binaryGenerator": "Intégration générative"
+      },
+      "incomplete": {
+        "title": "Cette liste est peut-être incomplète",
+        "body": "Les intégrations génératives n'ont pas pu être lues : un identifiant réclamé par l'une d'elles manque peut-être ci-dessous. Les clés enregistrées que personne ne réclame restent masquées tant que la liste ne peut pas être relue."
+      },
+      "orphaned": {
+        "heading": "Enregistrées mais non réclamées",
+        "body": "Rien de ce que ce déploiement a enregistré ne réclame ces clés, ce que laisse derrière elle une intégration retirée ou une variable renommée. Elles restent chiffrées jusqu'à ce que vous les supprimiez."
+      },
+      "toast": {
+        "loadFailed": "Impossible de charger les identifiants des capacités",
+        "saved": "{key} enregistré",
+        "saveFailed": "Impossible d'enregistrer l'identifiant",
+        "removeFailed": "Impossible de supprimer l'identifiant"
+      }
+    },
     "apiTokens": {
       "title": "Jetons d'accès à l'API",
       "intro": "Créez des jetons que les systèmes externes présentent à l'API cat-factory. Chaque jeton s'authentifie en tant que cet espace de travail sur les points de terminaison /api/v1. Le secret n'est affiché qu'une seule fois, à sa création, et ne peut pas être récupéré, alors conservez-le immédiatement.",

package/i18n/locales/he.json

@@ -2849,6 +2849,40 @@
         "removeFailed": "הסרת רשומת המאגר נכשלה"
       }
     },
+    "capabilityCredentials": {
+      "tab": "אישורי גישה ליכולות",
+      "intro": "הסודות ששרתי הכלים והאינטגרציות הגנרטיביות של הפריסה הזו מבקשים לפי שם. הערכים נשמרים ללוח הזה בלבד, מוצפנים במנוחה ומועברים ישירות לתהליך של הסוכן: הם לעולם לא מגיעים להנחיה או ליומן. הערכים ניתנים לכתיבה בלבד, ולכן ערך שמור מוחלף בהקלדת ערך חדש ולעולם אינו נקרא בחזרה.",
+      "credentialNoun": "אישור הגישה {key}",
+      "required": "נדרש",
+      "optional": "לא חובה",
+      "stored": "נשמר",
+      "storedAt": "הוגדר לאחרונה ב-{date}",
+      "notStoredWithFallback": "לא נשמר דבר עבור הלוח הזה. הפריסה הזו קוראת את המפתח גם מהסביבה שלה, ולכן ייתכן שהיכולת עדיין פועלת.",
+      "notStored": "לא נשמר דבר עבור הלוח הזה, ולפריסה הזו אין נפילה לסביבה, ולכן היכולת אינה יכולה לבצע אימות.",
+      "setValue": "ערך",
+      "replaceValue": "החלפת הערך השמור",
+      "save": "שמירה",
+      "remove": "הסרת אישור הגישה",
+      "noneDeclared": "אף אחת מהיכולות הרשומות בפריסה הזו אינה מבקשת אישור גישה.",
+      "subject": {
+        "toolServer": "שרת כלים",
+        "binaryGenerator": "אינטגרציה גנרטיבית"
+      },
+      "incomplete": {
+        "title": "ייתכן שהרשימה הזו חלקית",
+        "body": "לא ניתן היה לקרוא את האינטגרציות הגנרטיביות, ולכן ייתכן שחסר למטה אישור גישה שאחת מהן מבקשת. מפתחות שמורים שאיש אינו מבקש נשארים מוסתרים עד שאפשר יהיה לקרוא את הרשימה שוב."
+      },
+      "orphaned": {
+        "heading": "שמורים אך לא מבוקשים",
+        "body": "שום דבר שנרשם בפריסה הזו אינו מבקש את המפתחות האלה, וזה בדיוק מה שמשאירה אחריה אינטגרציה שהוסרה או משתנה ששמו שונה. הם יישארו מוצפנים עד שתסירו אותם."
+      },
+      "toast": {
+        "loadFailed": "לא ניתן היה לטעון את אישורי הגישה ליכולות",
+        "saved": "{key} נשמר",
+        "saveFailed": "לא ניתן היה לשמור את אישור הגישה",
+        "removeFailed": "לא ניתן היה להסיר את אישור הגישה"
+      }
+    },
     "apiTokens": {
       "title": "אסימוני גישה ל-API",
       "intro": "צור אסימונים שמערכות חיצוניות מציגות ל-API של cat-factory. כל אסימון מאמת את עצמו כמרחב העבודה הזה בנקודות הקצה /api/v1. הסוד מוצג פעם אחת בלבד, בעת היצירה, ולא ניתן לשחזרו, לכן שמור אותו מיד.",

package/i18n/locales/it.json

@@ -568,6 +568,40 @@
         "removeFailed": "Impossibile rimuovere la voce del registry"
       }
     },
+    "capabilityCredentials": {
+      "tab": "Credenziali delle capacità",
+      "intro": "I segreti che i server di strumenti e le integrazioni generative di questo deployment richiedono per nome. I valori vengono salvati solo per questa board, cifrati a riposo, e consegnati direttamente al processo dell'agente: non finiscono mai in un prompt né in un log. I valori sono di sola scrittura, quindi uno salvato si sostituisce digitandone uno nuovo e non viene mai riletto.",
+      "credentialNoun": "credenziale {key}",
+      "required": "Obbligatoria",
+      "optional": "Facoltativa",
+      "stored": "Salvata",
+      "storedAt": "Impostata l'ultima volta il {date}",
+      "notStoredWithFallback": "Per questa board non è salvato nulla. Questo deployment legge la chiave anche dal proprio ambiente, quindi la capacità potrebbe funzionare comunque.",
+      "notStored": "Per questa board non è salvato nulla e questo deployment non ha un ripiego sull'ambiente, quindi la capacità non può autenticarsi.",
+      "setValue": "Valore",
+      "replaceValue": "Sostituisci il valore salvato",
+      "save": "Salva",
+      "remove": "Rimuovi credenziale",
+      "noneDeclared": "Nessuna delle capacità registrate in questo deployment richiede credenziali.",
+      "subject": {
+        "toolServer": "Server di strumenti",
+        "binaryGenerator": "Integrazione generativa"
+      },
+      "incomplete": {
+        "title": "Questo elenco potrebbe essere incompleto",
+        "body": "Non è stato possibile leggere le integrazioni generative, quindi qui sotto potrebbe mancare una credenziale richiesta da una di esse. Le chiavi salvate che nessuno richiede restano nascoste finché l'elenco non può essere letto di nuovo."
+      },
+      "orphaned": {
+        "heading": "Salvate ma non richieste",
+        "body": "Nulla di ciò che questo deployment ha registrato richiede queste chiavi: è quello che lascia dietro di sé un'integrazione dismessa o una variabile rinominata. Restano cifrate finché non le rimuovi."
+      },
+      "toast": {
+        "loadFailed": "Impossibile caricare le credenziali delle capacità",
+        "saved": "{key} salvata",
+        "saveFailed": "Impossibile salvare la credenziale",
+        "removeFailed": "Impossibile rimuovere la credenziale"
+      }
+    },
     "apiTokens": {
       "title": "Token di accesso API",
       "intro": "Crea token che i sistemi esterni presentano all'API di cat-factory. Ogni token si autentica come questo spazio di lavoro sugli endpoint /api/v1. Il segreto viene mostrato una sola volta, al momento della creazione, e non può essere recuperato, quindi conservalo subito.",

package/i18n/locales/ja.json

@@ -2850,6 +2850,40 @@
         "removeFailed": "レジストリエントリを削除できませんでした"
       }
     },
+    "capabilityCredentials": {
+      "tab": "機能の認証情報",
+      "intro": "このデプロイのツールサーバーと生成系インテグレーションが名前で要求するシークレットです。値はこのボードにのみ保存され、保管時は暗号化され、エージェントのプロセスへ直接渡されます。プロンプトにもログにも現れません。値は書き込み専用なので、保存済みの値は新しい値を入力して置き換えるだけで、読み出すことはできません。",
+      "credentialNoun": "認証情報 {key}",
+      "required": "必須",
+      "optional": "任意",
+      "stored": "保存済み",
+      "storedAt": "最終設定: {date}",
+      "notStoredWithFallback": "このボードには何も保存されていません。このデプロイは自身の環境からもこのキーを読み取るため、機能は動作している可能性があります。",
+      "notStored": "このボードには何も保存されておらず、このデプロイには環境からのフォールバックもないため、機能は認証できません。",
+      "setValue": "値",
+      "replaceValue": "保存済みの値を置き換える",
+      "save": "保存",
+      "remove": "認証情報を削除",
+      "noneDeclared": "このデプロイに登録された機能で認証情報を要求するものはありません。",
+      "subject": {
+        "toolServer": "ツールサーバー",
+        "binaryGenerator": "生成系インテグレーション"
+      },
+      "incomplete": {
+        "title": "この一覧は不完全な可能性があります",
+        "body": "生成系インテグレーションを読み取れなかったため、いずれかが要求する認証情報が下の一覧から欠けている可能性があります。どこからも要求されていない保存済みのキーは、一覧を再び読み取れるようになるまで表示されません。"
+      },
+      "orphaned": {
+        "heading": "保存済みだが要求されていない",
+        "body": "このデプロイに登録されたもののうち、これらのキーを要求するものはありません。廃止されたインテグレーションや名前が変わった変数が残していったものです。削除するまで暗号化されたまま残ります。"
+      },
+      "toast": {
+        "loadFailed": "機能の認証情報を読み込めませんでした",
+        "saved": "{key} を保存しました",
+        "saveFailed": "認証情報を保存できませんでした",
+        "removeFailed": "認証情報を削除できませんでした"
+      }
+    },
     "apiTokens": {
       "title": "APIアクセストークン",
       "intro": "外部システムが cat-factory API に提示するトークンを作成します。各トークンは /api/v1 エンドポイントでこのワークスペースとして認証されます。シークレットは作成時に一度だけ表示され、復元できないため、すぐに保存してください。",

package/i18n/locales/pl.json

@@ -2709,6 +2709,40 @@
         "removeFailed": "Nie udało się usunąć wpisu rejestru"
       }
     },
+    "capabilityCredentials": {
+      "tab": "Poświadczenia funkcji",
+      "intro": "Sekrety, o które serwery narzędzi i integracje generatywne tego wdrożenia proszą po nazwie. Wartości są zapisywane tylko dla tej tablicy, szyfrowane w spoczynku i przekazywane wprost do procesu agenta: nigdy nie trafiają do promptu ani do logu. Wartości można tylko zapisywać, więc zapisaną zastępuje się, wpisując nową, i nigdy nie jest odczytywana.",
+      "credentialNoun": "poświadczenie {key}",
+      "required": "Wymagane",
+      "optional": "Opcjonalne",
+      "stored": "Zapisane",
+      "storedAt": "Ostatnio ustawione {date}",
+      "notStoredWithFallback": "Dla tej tablicy nic nie jest zapisane. To wdrożenie odczytuje klucz również z własnego środowiska, więc funkcja może nadal działać.",
+      "notStored": "Dla tej tablicy nic nie jest zapisane, a to wdrożenie nie ma awaryjnego odczytu ze środowiska, więc funkcja nie może się uwierzytelnić.",
+      "setValue": "Wartość",
+      "replaceValue": "Zastąp zapisaną wartość",
+      "save": "Zapisz",
+      "remove": "Usuń poświadczenie",
+      "noneDeclared": "Żadna z zarejestrowanych funkcji tego wdrożenia nie prosi o poświadczenia.",
+      "subject": {
+        "toolServer": "Serwer narzędzi",
+        "binaryGenerator": "Integracja generatywna"
+      },
+      "incomplete": {
+        "title": "Ta lista może być niepełna",
+        "body": "Nie udało się odczytać integracji generatywnych, więc poniżej może brakować poświadczenia, o które prosi jedna z nich. Zapisane klucze, o które nikt nie prosi, pozostają ukryte, dopóki listy nie da się odczytać ponownie."
+      },
+      "orphaned": {
+        "heading": "Zapisane, ale nieużywane",
+        "body": "Nic, co zarejestrowało to wdrożenie, nie prosi o te klucze. Właśnie to zostawia po sobie wycofana integracja albo zmiana nazwy zmiennej. Pozostaną zaszyfrowane, dopóki ich nie usuniesz."
+      },
+      "toast": {
+        "loadFailed": "Nie udało się wczytać poświadczeń funkcji",
+        "saved": "Zapisano {key}",
+        "saveFailed": "Nie udało się zapisać poświadczenia",
+        "removeFailed": "Nie udało się usunąć poświadczenia"
+      }
+    },
     "apiTokens": {
       "title": "Tokeny dostępu do API",
       "intro": "Twórz tokeny, które systemy zewnętrzne przedstawiają API cat-factory. Każdy token uwierzytelnia się jako ten obszar roboczy w punktach końcowych /api/v1. Sekret jest wyświetlany tylko raz, podczas tworzenia, i nie można go odzyskać, więc zapisz go od razu.",

package/i18n/locales/tr.json

@@ -2850,6 +2850,40 @@
         "removeFailed": "Kayıt defteri girdisi kaldırılamadı"
       }
     },
+    "capabilityCredentials": {
+      "tab": "Yetenek kimlik bilgileri",
+      "intro": "Bu kurulumdaki araç sunucularının ve üretken entegrasyonların adıyla istediği sırlar. Değerler yalnızca bu pano için saklanır, beklerken şifrelenir ve doğrudan ajanın sürecine verilir: ne bir isteme ne de bir günlüğe düşer. Değerler yalnızca yazılabilir, dolayısıyla saklanan bir değer yenisi yazılarak değiştirilir ve hiçbir zaman geri okunmaz.",
+      "credentialNoun": "{key} kimlik bilgisi",
+      "required": "Zorunlu",
+      "optional": "İsteğe bağlı",
+      "stored": "Saklanıyor",
+      "storedAt": "Son ayarlanma: {date}",
+      "notStoredWithFallback": "Bu pano için hiçbir şey saklanmıyor. Bu kurulum anahtarı kendi ortamından da okuyor, dolayısıyla yetenek hâlâ çalışıyor olabilir.",
+      "notStored": "Bu pano için hiçbir şey saklanmıyor ve bu kurulumun ortam yedeği yok, dolayısıyla yetenek kimlik doğrulaması yapamaz.",
+      "setValue": "Değer",
+      "replaceValue": "Saklanan değeri değiştir",
+      "save": "Kaydet",
+      "remove": "Kimlik bilgisini kaldır",
+      "noneDeclared": "Bu kurulumda kayıtlı yeteneklerin hiçbiri kimlik bilgisi istemiyor.",
+      "subject": {
+        "toolServer": "Araç sunucusu",
+        "binaryGenerator": "Üretken entegrasyon"
+      },
+      "incomplete": {
+        "title": "Bu liste eksik olabilir",
+        "body": "Üretken entegrasyonlar okunamadı, bu yüzden aşağıda bunlardan birinin istediği bir kimlik bilgisi eksik olabilir. Hiçbir şeyin istemediği saklanan anahtarlar, liste yeniden okunabilene kadar gizli kalır."
+      },
+      "orphaned": {
+        "heading": "Saklanıyor ama istenmiyor",
+        "body": "Bu kurulumun kaydettiği hiçbir şey bu anahtarları istemiyor; kaldırılmış bir entegrasyonun ya da adı değişmiş bir değişkenin geride bıraktığı tam olarak budur. Siz kaldırana kadar şifreli kalırlar."
+      },
+      "toast": {
+        "loadFailed": "Yetenek kimlik bilgileri yüklenemedi",
+        "saved": "{key} kaydedildi",
+        "saveFailed": "Kimlik bilgisi kaydedilemedi",
+        "removeFailed": "Kimlik bilgisi kaldırılamadı"
+      }
+    },
     "apiTokens": {
       "title": "API erişim belirteçleri",
       "intro": "Harici sistemlerin cat-factory API'sine sunduğu belirteçler oluşturun. Her belirteç, /api/v1 uç noktalarında bu çalışma alanı olarak kimlik doğrular. Gizli anahtar yalnızca oluşturulduğunda bir kez gösterilir ve kurtarılamaz, bu yüzden onu hemen saklayın.",

package/i18n/locales/uk.json

@@ -2709,6 +2709,40 @@
         "removeFailed": "Не вдалося видалити запис реєстру"
       }
     },
+    "capabilityCredentials": {
+      "tab": "Облікові дані можливостей",
+      "intro": "Секрети, які сервери інструментів і генеративні інтеграції цього розгортання запитують за іменем. Значення зберігаються лише для цієї дошки, зашифрованими, і передаються просто в процес агента: вони ніколи не потрапляють ані в підказку, ані в журнал. Значення доступні лише для запису, тож збережене замінюють, ввівши нове, і ніколи не читають назад.",
+      "credentialNoun": "облікові дані {key}",
+      "required": "Обовʼязкові",
+      "optional": "Необовʼязкові",
+      "stored": "Збережено",
+      "storedAt": "Востаннє задано {date}",
+      "notStoredWithFallback": "Для цієї дошки нічого не збережено. Це розгортання також читає ключ із власного середовища, тож можливість може й далі працювати.",
+      "notStored": "Для цієї дошки нічого не збережено, а запасного читання із середовища в цьому розгортанні немає, тож можливість не зможе пройти автентифікацію.",
+      "setValue": "Значення",
+      "replaceValue": "Замінити збережене значення",
+      "save": "Зберегти",
+      "remove": "Вилучити облікові дані",
+      "noneDeclared": "Жодна із зареєстрованих можливостей цього розгортання не запитує облікових даних.",
+      "subject": {
+        "toolServer": "Сервер інструментів",
+        "binaryGenerator": "Генеративна інтеграція"
+      },
+      "incomplete": {
+        "title": "Цей список може бути неповним",
+        "body": "Не вдалося прочитати генеративні інтеграції, тож нижче можуть бути відсутні облікові дані, які запитує одна з них. Збережені ключі, яких ніхто не запитує, лишаються прихованими, доки список не вдасться прочитати знову."
+      },
+      "orphaned": {
+        "heading": "Збережені, але не запитані",
+        "body": "Ніщо із зареєстрованого в цьому розгортанні не запитує ці ключі. Саме це лишає по собі вимкнена інтеграція або перейменована змінна. Вони лишатимуться зашифрованими, доки ви їх не вилучите."
+      },
+      "toast": {
+        "loadFailed": "Не вдалося завантажити облікові дані можливостей",
+        "saved": "{key} збережено",
+        "saveFailed": "Не вдалося зберегти облікові дані",
+        "removeFailed": "Не вдалося вилучити облікові дані"
+      }
+    },
     "apiTokens": {
       "title": "Токени доступу до API",
       "intro": "Створюйте токени, які зовнішні системи надають API cat-factory. Кожен токен автентифікується як цей робочий простір на кінцевих точках /api/v1. Секрет показується лише один раз, під час створення, і його не можна відновити, тож збережіть його одразу.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.208.1",
+  "version": "0.209.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",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.215.0"
+    "@cat-factory/contracts": "0.217.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",