@cat-factory/app 0.222.0 → 0.224.0

package/app/stores/agents.ts

@@ -7,6 +7,7 @@ import {
   AGENT_ARCHETYPES,
   AGENT_BY_KIND,
   setCustomAgentKindMeta,
+  setCustomCompanionTargets,
   SYSTEM_AGENT_META,
   uid,
 } from '~/utils/catalog'
@@ -105,6 +106,28 @@ export const useAgentsStore = defineStore('agents', () => {
   // no tick gap. The watch lives in the store's effect scope (disposed with it).
   watch(customByKind, (map) => setCustomAgentKindMeta(map), { immediate: true, flush: 'sync' })
 
+  /**
+   * The custom COMPANION pairings (companion kind → the producer kinds it reviews), read off the
+   * same custom-kind sources the palette is built from. Kept apart from `customByKind` because a
+   * pairing is not display metadata: the builder uses it to decide a kind is a TOGGLE on its
+   * producer rather than a placeable block, and `AgentArchetype` has no business carrying it.
+   */
+  const customCompanions = computed<Record<string, readonly AgentKind[]>>(() => {
+    const out: Record<string, readonly AgentKind[]> = {}
+    const add = (k: CustomAgentKind) => {
+      // A pairing with no targets is not a pairing. Recording it would make the kind vanish from
+      // the palette (an `isProducerCompanion` hit) with no producer to hang the toggle on.
+      if (k.companionTargets?.length) out[k.kind] = k.companionTargets
+    }
+    for (const k of consumerKinds.value) add(k)
+    for (const k of capabilitiesManifest.value?.slots?.agentKinds ?? []) add(k)
+    return out
+  })
+  watch(customCompanions, (map) => setCustomCompanionTargets(map), {
+    immediate: true,
+    flush: 'sync',
+  })
+
   /** Display metadata for a KNOWN kind (built-in / system / custom), else undefined. */
   function get(kind: AgentKind): AgentArchetype | undefined {
     return AGENT_BY_KIND[kind] ?? SYSTEM_AGENT_META[kind] ?? customByKind.value[kind]

package/app/stores/toolServers.spec.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useToolServersStore } from '~/stores/toolServers'
+import { useWorkspaceStore } from '~/stores/workspace'
+import type { ToolServerProbeResult, ToolServerView } from '~/types/toolServers'
+
+/**
+ * Three behaviours carry this store, each about not losing an answer:
+ *
+ *   - the availability probe. A 403 ("you may not manage secrets") is an ANSWER and resolves
+ *     normally, hiding the surface; anything else propagates, because the panel is what can tell a
+ *     reader the list could not be fetched. There is deliberately no 503 case, unlike the
+ *     credential store: projecting a registry needs no encryption key.
+ *   - a probe result is kept for every VERDICT, failures included. A failure is exactly the answer
+ *     the operator asked for, and a store that only kept successes would leave the row looking
+ *     untouched after a dead endpoint was reported.
+ *   - results survive a re-read of the inventory, because a result describes the SERVER rather than
+ *     the list it arrived in.
+ */
+function server(over: Partial<ToolServerView> = {}): ToolServerView {
+  return {
+    id: 'issues',
+    label: 'Issue tracker',
+    transport: 'http',
+    target: 'https://mcp.example/rpc',
+    declaredBy: ['coder'],
+    servableHarnesses: ['claude-code'],
+    credentials: [],
+    probeable: true,
+    ...over,
+  }
+}
+
+describe('toolServers store', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('load stores the inventory and marks the surface available', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listToolServers: () => Promise.resolve({ servers: [server()] }),
+    }))
+
+    const store = useToolServersStore()
+    await store.load()
+
+    expect(store.available).toBe(true)
+    expect(store.hasSurface).toBe(true)
+    expect(store.loading).toBe(false)
+  })
+
+  it('shares one read between concurrent callers', async () => {
+    let reads = 0
+    vi.stubGlobal('useApi', () => ({
+      listToolServers: () => {
+        reads++
+        return Promise.resolve({ servers: [server()] })
+      },
+    }))
+
+    const store = useToolServersStore()
+    // Both callers fire on the same interaction: the Infrastructure window asks `ensureLoaded` whether
+    // the tab exists at all, and the panel refreshes on mount so a redeploy shows up without a reload.
+    // A read that started microseconds ago IS that refresh, so it is shared rather than duplicated.
+    await Promise.all([store.ensureLoaded(), store.load()])
+
+    expect(reads).toBe(1)
+    expect(store.hasSurface).toBe(true)
+  })
+
+  it('a 403 latches the surface unavailable without throwing', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listToolServers: () => Promise.reject({ statusCode: 403 }),
+    }))
+
+    const store = useToolServersStore()
+    await expect(store.load()).resolves.toBeUndefined()
+
+    expect(store.available).toBe(false)
+    expect(store.hasSurface).toBe(false)
+  })
+
+  it('a transient failure propagates and latches nothing', async () => {
+    vi.stubGlobal('useApi', () => ({
+      listToolServers: () => Promise.reject({ statusCode: 500 }),
+    }))
+
+    const store = useToolServersStore()
+    await expect(store.load()).rejects.toBeDefined()
+
+    // `available` stays null so `ensureLoaded` remains retryable, and an already-loaded surface is
+    // not hidden by one bad read.
+    expect(store.available).toBeNull()
+  })
+
+  it('reports no surface for a deployment that registers no tool server', async () => {
+    vi.stubGlobal('useApi', () => ({ listToolServers: () => Promise.resolve({ servers: [] }) }))
+
+    const store = useToolServersStore()
+    await store.load()
+
+    // An answer rather than possibly an outage: the inventory is read off this process's own
+    // registry, which is why there is no `declarationsIncomplete` counterpart here.
+    expect(store.available).toBe(true)
+    expect(store.hasSurface).toBe(false)
+  })
+
+  it('keeps a FAILING probe result, and keeps it across a re-read of the inventory', async () => {
+    const failure: ToolServerProbeResult = {
+      serverId: 'issues',
+      status: 'unreachable',
+      error: 'TypeError: fetch failed',
+    }
+    vi.stubGlobal('useApi', () => ({
+      listToolServers: () => Promise.resolve({ servers: [server()] }),
+      probeToolServer: () => Promise.resolve(failure),
+    }))
+
+    const store = useToolServersStore()
+    await store.load()
+    await store.probe('issues')
+
+    expect(store.results.issues).toEqual(failure)
+    expect(store.probing).toBeNull()
+
+    await store.load()
+    expect(store.results.issues).toEqual(failure)
+  })
+
+  it('propagates a THROWN probe failure without storing a verdict', async () => {
+    // A 404 for a server the deployment has since dropped, or a transient 5xx: not a verdict, so the
+    // row must not claim the probe answered.
+    vi.stubGlobal('useApi', () => ({
+      probeToolServer: () => Promise.reject({ statusCode: 404 }),
+    }))
+
+    const store = useToolServersStore()
+    await expect(store.probe('ghost')).rejects.toBeDefined()
+
+    expect(store.results.ghost).toBeUndefined()
+    expect(store.probing).toBeNull()
+  })
+})

package/app/stores/toolServers.ts

@@ -0,0 +1,112 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { ToolServerProbeResult, ToolServersView } from '~/types/toolServers'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { apiErrorStatus } from '~/composables/api/errors'
+
+/**
+ * The deployment's tool servers (MCP) and the results of probing them.
+ *
+ * Two halves with different lifetimes, which is why they are separate refs. The INVENTORY is
+ * deployment code: it changes when the deployment redeploys, so it is loaded on demand and re-read
+ * rather than patched. A PROBE RESULT is a moment in time and belongs to the operator who asked for
+ * it, so results are kept per server id and never fetched eagerly — a probe spends an outbound
+ * request under the deployment's own credential, so opening a panel must not fire one.
+ *
+ * Mirrors the capability-credential store's availability handling deliberately: the two surfaces sit
+ * in one tab, gate on the same permission, and a member without it must see neither.
+ */
+export const useToolServersStore = defineStore('toolServers', () => {
+  const api = useApi()
+
+  const view = ref<ToolServersView | null>(null)
+  // Probe results by server id. Kept after a re-read of the inventory: a result describes the server
+  // rather than the list it arrived in, and dropping it on refresh would erase the answer the
+  // operator just asked for.
+  const results = ref<Record<string, ToolServerProbeResult>>({})
+  const probing = ref<string | null>(null)
+  const loading = ref(false)
+  // The backend's two definitive refusals: no `secrets.manage` (403), and — unlike the credential
+  // store — never a 503, since the inventory needs no encryption key to project a registry. `null`
+  // until first probed. A 403 HIDES the surface rather than disabling it, because the inventory
+  // names the deployment's credential keys and its endpoints.
+  const available = ref<boolean | null>(null)
+  let inFlight: Promise<void> | null = null
+
+  /**
+   * Whether there is anything to show. A deployment that registers no tool server has no row to
+   * render, and the panel section is hidden rather than rendering an empty heading.
+   *
+   * No `declarationsIncomplete` counterpart here, unlike the credential checklist: the inventory is
+   * read straight off this process's own registry, so an empty answer is an answer rather than
+   * possibly an outage.
+   */
+  const hasSurface = computed(() => (view.value?.servers.length ?? 0) > 0)
+
+  /**
+   * Refresh the inventory, sharing a read that is already in flight.
+   *
+   * Coalescing belongs on `load` and not only on `ensureLoaded` because both callers fire on the
+   * same interaction: the Infrastructure window calls `ensureLoaded` to decide whether the tab
+   * exists at all, and the panel refreshes on mount so a redeploy shows up without a reload. Two
+   * identical GETs per open is what a plain "force" would have cost, and a read that started
+   * microseconds ago IS the refresh.
+   */
+  async function load() {
+    if (inFlight) return inFlight
+    inFlight = readInventory().finally(() => (inFlight = null))
+    return inFlight
+  }
+
+  async function readInventory() {
+    const ws = useWorkspaceStore()
+    loading.value = true
+    try {
+      view.value = await api.listToolServers(ws.requireId())
+      available.value = true
+    } catch (err) {
+      if (apiErrorStatus(err) === 403) {
+        // A definitive answer, not a failure: this caller may not manage secrets. Hide the surface
+        // and stop probing; resolve normally.
+        available.value = false
+        view.value = null
+        return
+      }
+      // Any other failure (transient 5xx / network) leaves the state untouched, so it neither hides
+      // an available panel nor caches a false "unavailable", and PROPAGATES: the panel is the one
+      // surface that can tell a reader it is looking at a list we could not fetch. Same split as the
+      // capability-credential store.
+      throw err
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /** Load once and stay loaded; `load()` re-reads (both share whatever is in flight). */
+  async function ensureLoaded() {
+    if (available.value !== null) return
+    return load()
+  }
+
+  /**
+   * Probe ONE server and keep its result.
+   *
+   * The result is stored for every outcome, failures included: a failure IS the answer the operator
+   * asked for, and a store that only kept successes would leave the row looking untouched after the
+   * probe reported a dead endpoint. A thrown error (a 404 for a server the deployment has since
+   * dropped, a transient 5xx) propagates instead, because those are not probe verdicts.
+   */
+  async function probe(id: string) {
+    const ws = useWorkspaceStore()
+    probing.value = id
+    try {
+      const result = await api.probeToolServer(ws.requireId(), id)
+      results.value = { ...results.value, [id]: result }
+      return result
+    } finally {
+      probing.value = null
+    }
+  }
+
+  return { view, results, probing, loading, available, hasSurface, load, ensureLoaded, probe }
+})

package/app/types/toolServers.ts

@@ -0,0 +1,17 @@
+// Tool server (MCP) operability shapes: what this deployment declared, and what a probe answered.
+//
+// All wire shapes are sourced from @cat-factory/contracts (single source of truth). The probe
+// STATUS and the not-probeable REASON in particular are vocabularies both sides must agree about —
+// the backend decides them, this app maps each member to translated copy plus a remedy — so a
+// member added on one side only renders as a blank chip rather than failing to compile.
+
+export type {
+  ToolServerAllowedToolsCheck,
+  ToolServerCredential,
+  ToolServerNotProbeableReason,
+  ToolServerProbeResult,
+  ToolServerProbeStatus,
+  ToolServerTransport,
+  ToolServerView,
+  ToolServersView,
+} from '@cat-factory/contracts'

package/app/utils/catalog.companions.spec.ts

@@ -0,0 +1,80 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import type { AgentKind } from '~/types/domain'
+import {
+  COMPANION_FOR_PRODUCER,
+  __resetCustomCompanionTargetsForTest,
+  companionForProducer,
+  isProducerCompanion,
+  setCustomCompanionTargets,
+} from '~/utils/catalog'
+
+// The SPA half of the companion registry. A companion is not a placeable palette block: the
+// builder renders it as an "add companion" toggle ON its producer and inserts it immediately
+// after. These two lookups are what decide that, so a deployment's registered pair is either
+// visible as a toggle or invisible entirely, with nothing in between.
+//
+// The backend half is `extension-registries.companions.test.ts`. Both are needed: the backend
+// enforces the adjacency rule on save, and this decides whether a person can ever express the
+// pairing in the first place.
+
+afterEach(() => {
+  __resetCustomCompanionTargetsForTest()
+})
+
+describe('custom companion pairings in the palette', () => {
+  it('has no opinion about a deployment’s pair until the store projects it', () => {
+    // The pre-registration state is a real one: the snapshot arrives after first paint, and a
+    // custom companion must degrade to an ordinary kind rather than to a broken toggle.
+    expect(isProducerCompanion('acme:migration-auditor')).toBe(false)
+    expect(companionForProducer('acme:migrator')).toBeUndefined()
+  })
+
+  it('renders a registered pair as a toggle on its producer', () => {
+    setCustomCompanionTargets({ 'acme:migration-auditor': ['acme:migrator'] })
+    expect(companionForProducer('acme:migrator')).toBe('acme:migration-auditor')
+    // ...and the companion itself leaves the palette, which is the other half of "it is a
+    // toggle, not a block". Registering only one of these would show the kind twice.
+    expect(isProducerCompanion('acme:migration-auditor')).toBe(true)
+    // The producer is not a companion just for being reviewed by one.
+    expect(isProducerCompanion('acme:migrator')).toBe(false)
+  })
+
+  it('lets one companion review several producers', () => {
+    setCustomCompanionTargets({ 'acme:auditor': ['acme:migrator', 'acme:packager'] })
+    expect(companionForProducer('acme:migrator')).toBe('acme:auditor')
+    expect(companionForProducer('acme:packager')).toBe('acme:auditor')
+  })
+
+  it('never lets a deployment re-point a BUILT-IN producer at its own companion', () => {
+    // Built-ins win, matching `agentKindMeta`'s precedence and the backend registry's refusal to
+    // shadow a built-in kind. The shipped pairing is what every stock pipeline relies on, so a
+    // silent re-point would change what those pipelines do without anyone editing them.
+    setCustomCompanionTargets({ 'acme:reviewer': ['coder'] })
+    expect(companionForProducer('coder')).toBe(COMPANION_FOR_PRODUCER.coder)
+    // The custom kind still leaves the palette: it IS a companion, it just does not get `coder`.
+    expect(isProducerCompanion('acme:reviewer')).toBe(true)
+  })
+
+  it('resolves a contested producer deterministically, first registration winning', () => {
+    // Only one toggle can hang off a producer, so two companions claiming it is a case with an
+    // answer whether or not anyone chose one. Pinning it here is what keeps the answer from
+    // being "whichever the object happened to enumerate first".
+    const contested: Record<string, readonly AgentKind[]> = {
+      'acme:first': ['acme:migrator'],
+      'acme:second': ['acme:migrator'],
+    }
+    setCustomCompanionTargets(contested)
+    expect(companionForProducer('acme:migrator')).toBe('acme:first')
+    expect(isProducerCompanion('acme:second')).toBe(true)
+  })
+
+  it('drops a pairing when the catalog it came from goes away', () => {
+    setCustomCompanionTargets({ 'acme:migration-auditor': ['acme:migrator'] })
+    expect(companionForProducer('acme:migrator')).toBe('acme:migration-auditor')
+    // A workspace switch re-projects an empty catalog. The lookups must follow it rather than
+    // keep answering from the old deployment's registrations.
+    setCustomCompanionTargets({})
+    expect(companionForProducer('acme:migrator')).toBeUndefined()
+    expect(isProducerCompanion('acme:migration-auditor')).toBe(false)
+  })
+})

package/app/utils/catalog.spec.ts

@@ -37,6 +37,7 @@ const AGENT_KINDS: AgentKind[] = [
   'business-reviewer',
   'human-test',
   'visual-confirmation',
+  'disposer',
 ]
 const BLOCK_TYPES: BlockType[] = [
   'frontend',

package/app/utils/catalog.ts

@@ -1,4 +1,4 @@
-import { shallowRef } from 'vue'
+import { computed, shallowRef } from 'vue'
 import type {
   AgentArchetype,
   AgentCategory,
@@ -228,6 +228,21 @@ export const AGENT_ARCHETYPES: AgentArchetype[] = [
     // recreate / destroy) instead of the generic prose step-detail panel.
     resultView: 'human-test',
   },
+  {
+    // The `deployer`'s counterpart at the other end of the environment lifecycle, and a PALETTE
+    // block rather than a system kind precisely because deciding WHEN the environment goes away
+    // is the point of it: after the automated tester, or after a human has finished with the live
+    // URL. Without one, the TTL sweep reclaims environments on a timer long after the run
+    // settled, which is a fine backstop and cannot close the run's own teardown proof.
+    kind: 'disposer',
+    tier: 'intermediate',
+    label: 'Disposer',
+    icon: 'i-lucide-cloud-off',
+    color: '#34d399',
+    category: 'test',
+    description:
+      'Reclaims the ephemeral environments this run provisioned, and confirms they are actually gone. Place it after the last step that needs the environment.',
+  },
   {
     kind: 'visual-confirmation',
     tier: 'advanced',
@@ -322,9 +337,13 @@ export const COMPANION_ARCHETYPES: AgentArchetype[] = [
 ]
 
 /**
- * Producer agent kind → its companion agent kind. Mirrors the backend `COMPANIONS` registry
- * (`@cat-factory/agents`). The builder shows an "add companion" toggle on a producer step
- * found here, and inserts/removes the companion immediately after it.
+ * Producer agent kind → its companion agent kind, for the BUILT-IN pairs. Mirrors the backend
+ * `COMPANIONS` catalog (`@cat-factory/agents`). The builder shows an "add companion" toggle on
+ * a producer step found here, and inserts/removes the companion immediately after it.
+ *
+ * A DEPLOYMENT's own pair does not live here: it arrives on the snapshot as a custom agent
+ * kind carrying `companionTargets`, and is projected into {@link customCompanionTargets} by the
+ * agents store. Both are consulted below, built-ins first.
  */
 export const COMPANION_FOR_PRODUCER: Record<string, AgentKind> = {
   coder: 'reviewer',
@@ -335,18 +354,67 @@ export const COMPANION_FOR_PRODUCER: Record<string, AgentKind> = {
 
 const COMPANION_KINDS: ReadonlySet<string> = new Set(COMPANION_ARCHETYPES.map((a) => a.kind))
 
-/** The companion kind that depends on a producer kind, or undefined if it has none. */
+/**
+ * Reactive read-model of the deployment's CUSTOM companion pairings (companion kind → the
+ * producer kinds it reviews), kept in sync by the agents store from the snapshot's
+ * `customAgentKinds[].companionTargets`.
+ *
+ * A `shallowRef` for the same reason {@link customAgentKindMeta} is one: the pure lookups below
+ * must resolve a registered companion, and re-render when the catalog changes, without importing
+ * the store (circular) or mutating the frozen built-in map. Empty until the store first
+ * populates it, so a custom companion degrades to "not a companion" (an ordinary palette block),
+ * exactly as before registration.
+ */
+const customCompanionTargets = shallowRef<Record<string, readonly AgentKind[]>>({})
+
+/**
+ * The same projection INVERTED: producer kind → the companion that reviews it, the direction
+ * {@link companionForProducer} actually asks in. Derived rather than scanned per call, because
+ * that lookup runs once per step of every pipeline the builder renders.
+ *
+ * Inverting is also where an ambiguity has to be RESOLVED rather than left to iteration order:
+ * two registered companions may both claim a producer, and only one toggle can hang off it.
+ * First registration wins, stated here once, instead of "whichever `Object.entries` reached
+ * first" being the answer at each call site.
+ */
+const customCompanionByProducer = computed<Record<string, AgentKind>>(() => {
+  const out: Record<string, AgentKind> = {}
+  for (const [companion, targets] of Object.entries(customCompanionTargets.value)) {
+    for (const producer of targets) if (!(producer in out)) out[producer] = companion
+  }
+  return out
+})
+
+/** Replace the custom companion projection (called only by the agents store). */
+export function setCustomCompanionTargets(map: Record<string, readonly AgentKind[]>): void {
+  customCompanionTargets.value = map
+}
+
+/** Test-only: clear the custom companion projection so a spec starts from built-ins only. */
+export function __resetCustomCompanionTargetsForTest(): void {
+  customCompanionTargets.value = {}
+}
+
+/**
+ * The companion kind that depends on a producer kind, or undefined if it has none.
+ *
+ * Built-ins win. A deployment cannot re-point `coder` at its own reviewer by registering one,
+ * for the same reason `agentKindMeta`'s precedence puts built-ins first and the backend registry
+ * never shadows a built-in kind: the shipped pairing is the one the engine's own pipelines rely
+ * on, and a silent re-point would change what every stock pipeline does.
+ */
 export function companionForProducer(kind: string): AgentKind | undefined {
-  return COMPANION_FOR_PRODUCER[kind]
+  return COMPANION_FOR_PRODUCER[kind] ?? customCompanionByProducer.value[kind]
 }
 
 /**
  * Whether a kind is a dependent producer-companion (reviewer / architect-companion /
- * spec-companion) — rendered as a toggle on its producer, not a standalone palette block.
- * Distinct from `pipelineRender`'s `isCompanionKind`, which also counts the Tester's `fixer`.
+ * spec-companion, or a deployment's own): rendered as a toggle on its producer, not a
+ * standalone palette block. Distinct from `pipelineRender`'s `isCompanionKind`, which also
+ * counts the Tester's `fixer`.
  */
 export function isProducerCompanion(kind: string): boolean {
-  return COMPANION_KINDS.has(kind)
+  return COMPANION_KINDS.has(kind) || kind in customCompanionTargets.value
 }
 
 /**

package/i18n/locales/de.json

@@ -606,6 +606,48 @@
         "removeFailed": "Der Registry-Eintrag konnte nicht entfernt werden"
       }
     },
+    "toolServers": {
+      "heading": "Werkzeugserver (MCP)",
+      "intro": "Die MCP-Server, die diese Installation für ihre Agenten registriert. Ein Test löst die Zugangsdaten dieses Boards auf und spricht das Protokoll mit dem Server, das Ergebnis entspricht also dem, was ein Lauf erhält.",
+      "transport": {
+        "stdio": "Im Container",
+        "http": "Extern"
+      },
+      "declaredBy": "Zugewiesen an: {kinds}",
+      "declaredByNone": "Kein Agent erhält diesen Server, daher startet ihn kein Lauf.",
+      "servableHarnesses": "Läuft mit: {harnesses}",
+      "servableHarnessesNone": "Keine Agenten-CLI kann diesen Transport bedienen, daher greift dieser Server in keinem Lauf.",
+      "allowedTools": "Eingeschränkt auf: {tools}",
+      "credentials": "Zugangsdaten: {keys}",
+      "test": "Testen",
+      "notProbeable": {
+        "stdio": "Läuft im Container des Agenten und kann von hier aus nicht getestet werden.",
+        "containerLocal": "Lauscht neben dem Agenten in dessen eigenem Container, der von hier aus nicht erreichbar ist.",
+        "urlNotAllowed": "Unter dieser Adresse darf ein Werkzeugserver nicht erreicht werden (https oder einfaches http nur auf localhost)."
+      },
+      "status": {
+        "ok": "Hat geantwortet",
+        "credentialsMissing": "Keine Zugangsdaten",
+        "credentialRefused": "Zugangsdaten abgelehnt",
+        "unreachable": "Keine Antwort",
+        "httpError": "Anfrage abgewiesen",
+        "protocolError": "Kein MCP-Server",
+        "notProbeable": "Von hier nicht testbar"
+      },
+      "okDetail": "{name} {version}, Protokoll {protocol}, {count} Werkzeuge.",
+      "toolsIncomplete": "Der Server hat mehr Werkzeuge, als ein Test liest, diese Zahl ist also ein Mindestwert.",
+      "unmatchedTools": "Dieser Server bietet kein Werkzeug namens {tools}, dem Agenten wird also ein Werkzeug angekündigt, das er nicht aufrufen kann.",
+      "allowedToolsUnchecked": "Die Werkzeugliste war zu lang, um sie vollständig zu lesen, daher konnten die eingeschränkten Namen nicht geprüft werden.",
+      "unresolvedCredentials": "Für {keys} wurde nichts aufgelöst. Trage den Wert unten ein oder setze ihn in der Umgebung der Installation.",
+      "refusedCredentials": "{keys} benennt eine Variable, die zur Konfiguration der Plattform selbst gehört, und wird daher nie aufgelöst. Ändere die Deklaration im Code der Installation.",
+      "httpStatus": "HTTP {status}",
+      "showDetails": "Details anzeigen",
+      "hideDetails": "Details verbergen",
+      "toast": {
+        "loadFailed": "Die Werkzeugserver konnten nicht geladen werden",
+        "probeFailed": "Der Werkzeugserver konnte nicht getestet 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.",
@@ -1491,6 +1533,12 @@
       "inherited": "vom Service geerbt",
       "frozen": "Eingefroren: der Agent hat gestartet"
     },
+    "taskTypeFields": {
+      "title": "Aufgabentyp-Felder",
+      "hint": "Die Antworten, die dieser Aufgabentyp benötigt. Fehlt eine Pflichtangabe, wird ein Lauf vor dem Start angehalten.",
+      "save": "Speichern",
+      "revert": "Zurücksetzen"
+    },
     "dependencies": {
       "title": "Hängt ab von",
       "hint": "Aufgaben, die gemergt sein müssen, bevor diese laufen kann. Das Run-Steuerelement bleibt gesperrt, bis jede Abhängigkeit erledigt ist.",
@@ -5519,6 +5567,11 @@
         "title": "Keine Erfolgskriterien",
         "hint": "Nenne die Frage, die der Spike beantwortet, oder wie ein gutes Ergebnis aussieht, damit die Zeitbox ein Ziel hat."
       },
+      "required_field_missing": {
+        "title": "Fehlt: {field}",
+        "hint": "Dieser Aufgabentyp verlangt „{field}“, die Aufgabe beantwortet es aber nicht. Trage es an der Aufgabe nach und prüfe erneut.",
+        "unnamedField": "ein Pflichtfeld"
+      },
       "unknown": {
         "title": "Unbekannter Befund",
         "hint": "Dieser Lauf hat eine Prüfung erfasst, die diese Version nicht mehr kennt. Sieh die Aufgabe von Hand durch, bevor du fortfährst."
@@ -5872,6 +5925,7 @@
     "operation": {
       "provision": "Hochfahren",
       "teardown": "Abbauen",
+      "teardown-verify": "Abbau-Prüfung",
       "status": "Statusprüfung",
       "dispatch": "Hochfahren",
       "release": "Abbauen",