@cat-factory/app 0.221.2 → 0.223.0

package/app/components/layout/NotificationsInbox.vue

@@ -84,6 +84,10 @@ const META: Record<Notification['type'], { icon: string; color: Accent }> = {
   // Runs were paused by the spend safeguard. Workspace-scoped (no block to reveal); "act" just
   // marks it read (the human raises the budget then resumes from the spend panel).
   budget_paused: { icon: 'i-lucide-wallet', color: 'warning' },
+  // Spend crossed an alert threshold, or is projected to overrun the budget before the period
+  // ends. The PROACTIVE sibling of `budget_paused`, so it is amber rather than red: nothing has
+  // stopped yet, which is the entire point of it arriving. "act" just marks it read.
+  budget_threshold: { icon: 'i-lucide-trending-up', color: 'warning' },
   // Stored credentials could not be decrypted (the ENCRYPTION_KEY changed since they were
   // sealed). Not block-scoped; "act" drops the listed stale ciphertexts so they can be re-entered
   // (or restore the previous key to recover them instead).
@@ -117,6 +121,7 @@ const ACTION_KEYS: Record<Notification['type'], string> = {
   initiative: 'layout.notifications.action.initiative',
   platform_health: 'layout.notifications.action.platform_health',
   budget_paused: 'layout.notifications.action.budget_paused',
+  budget_threshold: 'layout.notifications.action.budget_threshold',
   key_drift: 'layout.notifications.action.key_drift',
   infra_unreachable: 'layout.notifications.action.infra_unreachable',
 }

package/app/components/panels/ReportsPanel.vue

@@ -352,6 +352,34 @@ watch(
               </section>
             </div>
 
+            <!-- The TCO axes: what a repository and a ticket actually cost. Spend-only, like the
+                 pair above, because a run's activity is already sliced by the service that owns
+                 the repo and there is no second population to pair a ticket with. -->
+            <div class="grid gap-6 md:grid-cols-2">
+              <section>
+                <h2 class="mb-2 text-xs font-semibold uppercase tracking-wide text-slate-500">
+                  {{ t('reports.spend.byRepo') }}
+                </h2>
+                <ReportsSpendBreakdown
+                  :rows="view.spend.byRepo"
+                  :currency="currency"
+                  test-id="reports-spend-repo"
+                  :label-of="sliceLabel"
+                />
+              </section>
+              <section>
+                <h2 class="mb-2 text-xs font-semibold uppercase tracking-wide text-slate-500">
+                  {{ t('reports.spend.byTicket') }}
+                </h2>
+                <ReportsSpendBreakdown
+                  :rows="view.spend.byTicket"
+                  :currency="currency"
+                  test-id="reports-spend-ticket"
+                  :label-of="sliceLabel"
+                />
+              </section>
+            </div>
+
             <!-- The shared axis: spend AND activity for the same grouping, side by side. -->
             <section class="flex flex-col gap-3">
               <div class="flex flex-wrap items-center gap-2">

package/app/components/settings/CapabilityCredentialsPanel.vue

@@ -16,6 +16,7 @@
 import { computed, onMounted, reactive, ref } from 'vue'
 import type { CapabilityCredentialStatus } from '~/types/capabilityCredentials'
 import SecretInput from '~/components/common/SecretInput.vue'
+import ToolServerChecklist from '~/components/settings/ToolServerChecklist.vue'
 
 const { t, d } = useI18n()
 const store = useCapabilityCredentialsStore()
@@ -63,6 +64,19 @@ onMounted(async () => {
   }
 })
 
+// The tool-server inventory that renders above the checklist. Its own read (and its own failure
+// report, for the same reason): the two surfaces answer different questions off different endpoints,
+// so one failing must not blank the other. Both resolve the same 403, so this is only reached by a
+// caller the backend has already admitted.
+const toolServers = useToolServersStore()
+onMounted(async () => {
+  try {
+    await toolServers.load()
+  } catch (e) {
+    present(e, 'settings.toolServers.toast.loadFailed')
+  }
+})
+
 async function saveKey(key: string) {
   const value = (drafts[key] ?? '').trim()
   if (!value) return
@@ -99,6 +113,11 @@ async function removeKey(key: string) {
 
 <template>
   <div class="space-y-4" data-testid="capability-credentials-panel">
+    <!-- The servers FIRST, because they are what the keys below authenticate: a bare list of
+         variable names does not tell an operator which of them matters, and the Test button is the
+         only thing on either surface that can say whether the value they typed works. -->
+    <ToolServerChecklist />
+
     <p class="text-sm text-slate-400">
       {{ t('settings.capabilityCredentials.intro') }}
     </p>

package/app/components/settings/InfrastructureWindow.vue

@@ -15,10 +15,11 @@
 //   - "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.
+//   - "Capability credentials" — the deployment's tool servers (MCP) with a Test button each, above
+//     the sealed per-workspace values behind the secrets a registered tool server or generative
+//     binary integration declares. What an agent's tools authenticate as belongs beside where those
+//     agents run, and it is `secrets.manage`-only (the READ included, since both halves name the
+//     deployment's credential keys), so the tab is HIDDEN rather than disabled for anyone else.
 // 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'
@@ -43,6 +44,7 @@ const store = useProviderConnectionsStore()
 const auth = useAuthStore()
 const packageRegistries = usePackageRegistriesStore()
 const capabilityCredentials = useCapabilityCredentialsStore()
+const toolServers = useToolServersStore()
 const { canManageSecrets } = useWorkspaceAccess()
 
 const open = computed({
@@ -93,7 +95,14 @@ const tabs = computed(() =>
     // 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,
+    //
+    // EITHER surface earns the tab. A tool server that declares no credential has nothing on the
+    // checklist, and gating the tab on the checklist alone would leave the one server an operator
+    // most wants to test unreachable — while a credential whose capability is a generative
+    // integration has no tool-server row. Two questions, one tab, and neither is a subset of the
+    // other.
+    capabilityCredentials:
+      canManageSecrets.value && (capabilityCredentials.hasSurface || toolServers.hasSurface),
   }).map((value) => ({
     value,
     label: TAB_LABELS.value[value],
@@ -121,7 +130,10 @@ watch(
     // 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(() => {})
+    if (canManageSecrets.value) {
+      void capabilityCredentials.ensureLoaded().catch(() => {})
+      void toolServers.ensureLoaded().catch(() => {})
+    }
     activeTab.value = openInfrastructureTab(tabValues.value, ui.infrastructureTab)
   },
   { immediate: true },

package/app/components/settings/ToolServerChecklist.vue

@@ -0,0 +1,264 @@
+<script setup lang="ts">
+// Tool servers (MCP) — the deployment's registered servers, and a Test button that speaks the
+// protocol to one.
+//
+// It sits ABOVE the credential checklist in the same tab, because it is what the credentials on that
+// list are FOR: the checklist answers "which keys does this deployment want", and this answers "and
+// does the server they authenticate actually work". Both are `secrets.manage`-only, which is why the
+// tab is hidden rather than disabled for anyone else.
+//
+// A row states four independent reasons a declared server may never reach a run — no kind declares
+// it, no harness can serve its transport, its credentials do not resolve, the endpoint is dead — and
+// each is rendered rather than implied. Before this panel the first two lived in a boot log and the
+// deployment's own source, and the last two were only visible by starting a run and reading the
+// agent's prompt.
+import { computed, ref } from 'vue'
+import type {
+  ToolServerNotProbeableReason,
+  ToolServerProbeStatus,
+  ToolServerTransport,
+  ToolServerView,
+} from '~/types/toolServers'
+
+const { t } = useI18n()
+const store = useToolServersStore()
+const { present } = usePipelineErrorToast()
+
+// Which failure DETAILS are expanded, by server id. Collapsed by default: the translated status line
+// is what an operator acts on, and the raw backend prose is a disclosure behind it (never the
+// primary description) per the i18n rule.
+const expanded = ref<Record<string, boolean>>({})
+
+// Exhaustive Records over the wire vocabularies, so a member added in `@cat-factory/contracts` fails
+// to compile here until it has translated copy. The sanctioned guard for an enum-keyed lookup the
+// typed-message-key check cannot see.
+const TRANSPORT_LABELS = computed<Record<ToolServerTransport, string>>(() => ({
+  stdio: t('settings.toolServers.transport.stdio'),
+  http: t('settings.toolServers.transport.http'),
+}))
+const STATUS_LABELS = computed<Record<ToolServerProbeStatus, string>>(() => ({
+  ok: t('settings.toolServers.status.ok'),
+  credentials_missing: t('settings.toolServers.status.credentialsMissing'),
+  credential_refused: t('settings.toolServers.status.credentialRefused'),
+  unreachable: t('settings.toolServers.status.unreachable'),
+  http_error: t('settings.toolServers.status.httpError'),
+  protocol_error: t('settings.toolServers.status.protocolError'),
+  not_probeable: t('settings.toolServers.status.notProbeable'),
+}))
+const NOT_PROBEABLE_LABELS = computed<Record<ToolServerNotProbeableReason, string>>(() => ({
+  stdio_transport: t('settings.toolServers.notProbeable.stdio'),
+  container_local_url: t('settings.toolServers.notProbeable.containerLocal'),
+  url_not_allowed: t('settings.toolServers.notProbeable.urlNotAllowed'),
+}))
+
+const servers = computed<ToolServerView[]>(() => store.view?.servers ?? [])
+
+function resultFor(id: string) {
+  return store.results[id]
+}
+
+/** Success is the only green; every other verdict names something for the operator to fix. */
+function statusColor(status: ToolServerProbeStatus): 'success' | 'warning' | 'error' {
+  if (status === 'ok') return 'success'
+  return status === 'not_probeable' ? 'warning' : 'error'
+}
+
+async function runProbe(id: string) {
+  try {
+    await store.probe(id)
+  } catch (e) {
+    // A THROWN failure is not a verdict — a 404 for a server the deployment has since dropped, or a
+    // transient 5xx. Presented through the shared status-class funnel rather than stored as a
+    // result, so the row does not claim the probe answered.
+    present(e, 'settings.toolServers.toast.probeFailed')
+  }
+}
+</script>
+
+<template>
+  <section v-if="servers.length" class="space-y-3" data-testid="tool-servers-section">
+    <div>
+      <h3 class="text-sm font-semibold text-slate-200">
+        {{ t('settings.toolServers.heading') }}
+      </h3>
+      <p class="text-xs text-slate-400">{{ t('settings.toolServers.intro') }}</p>
+    </div>
+
+    <article
+      v-for="server in servers"
+      :key="server.id"
+      class="space-y-2 rounded-lg border border-slate-700 p-3"
+      :data-testid="`tool-server-${server.id}`"
+    >
+      <div class="flex flex-wrap items-center gap-2">
+        <span class="text-sm font-medium text-slate-200">{{ server.label }}</span>
+        <UBadge color="neutral" variant="soft" size="sm">
+          {{ TRANSPORT_LABELS[server.transport] }}
+        </UBadge>
+        <code class="font-mono text-[11px] text-slate-500">{{ server.id }}</code>
+      </div>
+
+      <p class="truncate font-mono text-[11px] text-slate-500" :title="server.target">
+        {{ server.target }}
+      </p>
+      <p v-if="server.guidance" class="text-xs text-slate-400">{{ server.guidance }}</p>
+
+      <!-- Which agents get it. An EMPTY list is a registration attached to nothing: it never reaches
+           a dispatch, so the credentials it asks for are keys an operator fills in for no run. Said
+           out loud, because no other surface in the platform can see that state. -->
+      <p v-if="server.declaredBy.length" class="text-[11px] text-slate-400">
+        {{ t('settings.toolServers.declaredBy', { kinds: server.declaredBy.join(', ') }) }}
+      </p>
+      <p v-else class="text-[11px] text-amber-400" :data-testid="`tool-server-orphan-${server.id}`">
+        {{ t('settings.toolServers.declaredByNone') }}
+      </p>
+
+      <!-- Which harnesses could serve it. EMPTY means the declaration can never run anywhere (an
+           `http` server narrowed to Codex, whose MCP client is stdio-only): it is never dropped FOR
+           A REASON on any run, so no prompt and no log line ever mentions it. -->
+      <p v-if="server.servableHarnesses.length" class="text-[11px] text-slate-400">
+        {{
+          t('settings.toolServers.servableHarnesses', {
+            harnesses: server.servableHarnesses.join(', '),
+          })
+        }}
+      </p>
+      <p v-else class="text-[11px] text-amber-400">
+        {{ t('settings.toolServers.servableHarnessesNone') }}
+      </p>
+
+      <p v-if="server.allowedTools?.length" class="text-[11px] text-slate-400">
+        {{ t('settings.toolServers.allowedTools', { tools: server.allowedTools.join(', ') }) }}
+      </p>
+      <p v-if="server.credentials.length" class="text-[11px] text-slate-400">
+        {{
+          t('settings.toolServers.credentials', {
+            keys: server.credentials.map((c) => c.key).join(', '),
+          })
+        }}
+      </p>
+
+      <div class="flex flex-wrap items-center gap-2 pt-1">
+        <UButton
+          v-if="server.probeable"
+          size="xs"
+          variant="subtle"
+          icon="i-lucide-plug"
+          :loading="store.probing === server.id"
+          :disabled="store.probing !== null"
+          :data-testid="`tool-server-test-${server.id}`"
+          @click="runProbe(server.id)"
+        >
+          {{ t('settings.toolServers.test') }}
+        </UButton>
+        <!-- Not a disabled button: nothing the operator can do here makes it clickable, so the row
+             states the reason instead. Each reason needs a different response — nothing to fix,
+             verify it from a run, or change the declaration. -->
+        <p
+          v-else-if="server.notProbeableReason"
+          class="text-[11px] text-slate-500"
+          :data-testid="`tool-server-unprobeable-${server.id}`"
+        >
+          {{ NOT_PROBEABLE_LABELS[server.notProbeableReason] }}
+        </p>
+      </div>
+
+      <div
+        v-if="resultFor(server.id)"
+        class="space-y-1 rounded-md border border-slate-800 bg-slate-900/40 p-2"
+        :data-testid="`tool-server-result-${server.id}`"
+      >
+        <div class="flex flex-wrap items-center gap-2">
+          <UBadge
+            :color="statusColor(resultFor(server.id)!.status)"
+            variant="soft"
+            size="sm"
+            :data-testid="`tool-server-status-${server.id}`"
+          >
+            {{ STATUS_LABELS[resultFor(server.id)!.status] }}
+          </UBadge>
+          <span v-if="resultFor(server.id)!.httpStatus" class="text-[11px] text-slate-400">
+            {{ t('settings.toolServers.httpStatus', { status: resultFor(server.id)!.httpStatus }) }}
+          </span>
+        </div>
+
+        <p v-if="resultFor(server.id)!.status === 'ok'" class="text-[11px] text-slate-300">
+          {{
+            t('settings.toolServers.okDetail', {
+              name: resultFor(server.id)!.serverName || server.id,
+              version: resultFor(server.id)!.serverVersion || '?',
+              protocol: resultFor(server.id)!.protocolVersion ?? '?',
+              count: resultFor(server.id)!.toolCount ?? 0,
+            })
+          }}
+        </p>
+        <!-- A count off a truncated read is a FLOOR, not a total, and the difference decides whether
+             the allowedTools verdict below means anything. -->
+        <p v-if="resultFor(server.id)!.toolsComplete === false" class="text-[11px] text-slate-500">
+          {{ t('settings.toolServers.toolsIncomplete') }}
+        </p>
+
+        <!-- The reconciliation nothing else in the platform can do: a well-formed tool name that
+             matches nothing narrows the CLI's allow-list to a dead pattern while the prompt keeps
+             advertising the tool. Withheld entirely when the tool list was a prefix. -->
+        <p
+          v-if="resultFor(server.id)!.allowedTools?.unmatched?.length"
+          class="text-[11px] text-amber-400"
+          :data-testid="`tool-server-unmatched-${server.id}`"
+        >
+          {{
+            t('settings.toolServers.unmatchedTools', {
+              tools: resultFor(server.id)!.allowedTools!.unmatched.join(', '),
+            })
+          }}
+        </p>
+        <p
+          v-else-if="resultFor(server.id)!.allowedTools?.checked === false"
+          class="text-[11px] text-slate-500"
+        >
+          {{ t('settings.toolServers.allowedToolsUnchecked') }}
+        </p>
+
+        <p
+          v-if="resultFor(server.id)!.unresolvedCredentials?.length"
+          class="text-[11px] text-amber-400"
+        >
+          {{
+            t('settings.toolServers.unresolvedCredentials', {
+              keys: resultFor(server.id)!.unresolvedCredentials!.join(', '),
+            })
+          }}
+        </p>
+        <p v-if="resultFor(server.id)!.refusedCredentials?.length" class="text-[11px] text-red-400">
+          {{
+            t('settings.toolServers.refusedCredentials', {
+              keys: resultFor(server.id)!.refusedCredentials!.join(', '),
+            })
+          }}
+        </p>
+
+        <!-- Raw backend prose is DETAIL behind a disclosure, never the primary description. It is
+             already scrubbed through `redactSecrets` at the emit site. -->
+        <template v-if="resultFor(server.id)!.error">
+          <UButton
+            size="xs"
+            variant="link"
+            class="px-0"
+            :data-testid="`tool-server-details-${server.id}`"
+            @click="expanded[server.id] = !expanded[server.id]"
+          >
+            {{
+              expanded[server.id]
+                ? t('settings.toolServers.hideDetails')
+                : t('settings.toolServers.showDetails')
+            }}
+          </UButton>
+          <pre
+            v-if="expanded[server.id]"
+            class="overflow-x-auto rounded bg-slate-950 p-2 font-mono text-[10px] text-slate-400"
+            >{{ resultFor(server.id)!.error }}</pre>
+        </template>
+      </div>
+    </article>
+  </section>
+</template>

package/app/components/slack/SlackPanel.vue

@@ -74,6 +74,7 @@ const routes = reactive<Record<NotificationType, SlackRoute>>({
   initiative: { enabled: false, channel: '' },
   platform_health: { enabled: false, channel: '' },
   budget_paused: { enabled: false, channel: '' },
+  budget_threshold: { enabled: false, channel: '' },
   // In-app only (not in ROUTABLE), but the map is exhaustive over the type.
   key_drift: { enabled: false, channel: '' },
   infra_unreachable: { enabled: false, channel: '' },

package/app/composables/api/toolServers.ts

@@ -0,0 +1,21 @@
+import { listToolServersContract, probeToolServerContract } from '@cat-factory/contracts'
+import type { ApiContext } from './context'
+
+/**
+ * Per-workspace tool-server (MCP) operability: the inventory of what this deployment declared, and
+ * a probe that speaks the protocol to one of them.
+ *
+ * `secrets.manage`-gated end to end, the READ included — the inventory names the credential keys the
+ * deployment's capabilities want and the endpoints those credentials are sent to. The probe is a
+ * POST because it SPENDS an outbound request under the deployment's own credential, so it must not
+ * be safe to retry from a cache or a prefetch. See ToolServerController.
+ */
+export function toolServersApi({ send, ws }: ApiContext) {
+  return {
+    listToolServers: (workspaceId: string) =>
+      send(listToolServersContract, { pathPrefix: ws(workspaceId) }),
+
+    probeToolServer: (workspaceId: string, id: string) =>
+      send(probeToolServerContract, { pathPrefix: ws(workspaceId), pathParams: { id } }),
+  }
+}

package/app/composables/useApi.ts

@@ -33,6 +33,7 @@ import { modelsApi } from './api/models'
 import { notificationsApi } from './api/notifications'
 import { packageRegistriesApi } from './api/packageRegistries'
 import { capabilityCredentialsApi } from './api/capabilityCredentials'
+import { toolServersApi } from './api/toolServers'
 import { preflightsApi } from './api/preflights'
 import { presetsApi } from './api/presets'
 import { publicApiKeysApi } from './api/publicApiKeys'
@@ -156,6 +157,7 @@ export function useApi() {
     ...testSecretsApi(ctx),
     ...packageRegistriesApi(ctx),
     ...capabilityCredentialsApi(ctx),
+    ...toolServersApi(ctx),
     ...previewApi(ctx),
     ...environmentsApi(ctx),
     ...recurringApi(ctx),

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()
+  })
+})