@cat-factory/app 0.232.2 → 0.234.0

package/app/components/settings/TaskTypeSuppressionsPanel.vue

@@ -0,0 +1,119 @@
+<script setup lang="ts">
+// Workspace settings: which of the deployment's REUSABLE OPERATIONS this board offers
+// (`backend/docs/reusable-operations.md`). An org registers its operations process-wide, so a
+// team that runs three of twenty needs a way to clear the rest out of its create picker.
+//
+// The list comes from its OWN read, not from the board snapshot's `customTaskTypes`: a suppressed
+// operation is by construction absent from that catalog, so this screen is the only surface that
+// can offer the way back. Every write answers with the whole list AND invalidates the catalog the
+// picker renders, so a change is followed by a board refresh rather than a local patch.
+//
+// Labels and descriptions are DEPLOYMENT-authored English rendered verbatim (the descriptor
+// convention); only the chrome around them is i18n.
+import { onMounted, ref } from 'vue'
+import type { TaskTypeSuppression } from '~/types/domain'
+
+const { t } = useI18n()
+const api = useApi()
+const workspace = useWorkspaceStore()
+const toast = useToast()
+
+const rows = ref<TaskTypeSuppression[]>([])
+const loading = ref(false)
+/** The single id being written, so only its own switch shows the pending state. */
+const busyId = ref<string | null>(null)
+
+onMounted(() => void load())
+
+async function load() {
+  if (!workspace.workspaceId) return
+  loading.value = true
+  try {
+    rows.value = (await api.listTaskTypeSuppressions(workspace.requireId())).taskTypes
+  } catch (e) {
+    fail(e)
+  } finally {
+    loading.value = false
+  }
+}
+
+/**
+ * Flip one operation. The board snapshot's task-type catalog is derived from this state, so a
+ * successful write refreshes the workspace: leaving it stale would keep offering a hidden
+ * operation in the create picker until the next unrelated reload.
+ */
+async function toggle(row: TaskTypeSuppression, offered: boolean) {
+  const id = row.taskType.taskType
+  busyId.value = id
+  try {
+    const result = offered
+      ? await api.restoreTaskType(workspace.requireId(), id)
+      : await api.suppressTaskType(workspace.requireId(), id)
+    rows.value = result.taskTypes
+    await workspace.refresh()
+  } catch (e) {
+    fail(e)
+  } finally {
+    busyId.value = null
+  }
+}
+
+function fail(e: unknown) {
+  toast.add({
+    title: t('settings.taskTypeSuppressions.saveFailed'),
+    description: e instanceof Error ? e.message : String(e),
+    icon: 'i-lucide-triangle-alert',
+    color: 'error',
+  })
+}
+</script>
+
+<template>
+  <div class="space-y-4">
+    <p class="text-xs text-slate-400">
+      {{ t('settings.taskTypeSuppressions.intro') }}
+    </p>
+
+    <p v-if="loading" class="text-[11px] text-slate-500">
+      {{ t('settings.taskTypeSuppressions.loading') }}
+    </p>
+    <p v-else-if="!rows.length" class="text-[11px] text-slate-500">
+      {{ t('settings.taskTypeSuppressions.empty') }}
+    </p>
+    <ul v-else class="space-y-2" data-testid="task-type-suppressions">
+      <li
+        v-for="row in rows"
+        :key="row.taskType.taskType"
+        class="flex items-start justify-between gap-3 rounded border border-slate-800 px-3 py-2"
+        data-testid="task-type-suppression"
+        :data-task-type="row.taskType.taskType"
+      >
+        <div class="min-w-0">
+          <div class="flex items-center gap-1.5">
+            <UIcon :name="row.taskType.presentation.icon" class="h-3.5 w-3.5 shrink-0" />
+            <span class="truncate text-xs font-medium text-slate-200">
+              {{ row.taskType.presentation.label }}
+            </span>
+            <UBadge
+              v-if="row.taskType.presentation.category"
+              color="neutral"
+              variant="subtle"
+              size="sm"
+            >
+              {{ row.taskType.presentation.category }}
+            </UBadge>
+          </div>
+          <p class="mt-0.5 text-[11px] text-slate-500">
+            {{ row.taskType.presentation.description }}
+          </p>
+        </div>
+        <USwitch
+          :model-value="!row.suppressed"
+          :loading="busyId === row.taskType.taskType"
+          :aria-label="t('settings.taskTypeSuppressions.offer')"
+          @update:model-value="(offered: boolean) => toggle(row, offered)"
+        />
+      </li>
+    </ul>
+  </div>
+</template>

package/app/components/settings/WorkspaceSettingsPanel.vue

@@ -15,6 +15,7 @@ import type { InputGateMode, ReviewFrictionMode, TaskLimitMode } from '~/types/d
 import RiskPolicyPanel from '~/components/settings/RiskPolicyPanel.vue'
 import IssueTrackerPanel from '~/components/settings/IssueTrackerPanel.vue'
 import ServiceFragmentDefaultsPanel from '~/components/settings/ServiceFragmentDefaultsPanel.vue'
+import TaskTypeSuppressionsPanel from '~/components/settings/TaskTypeSuppressionsPanel.vue'
 import BudgetSettings from '~/components/settings/BudgetSettings.vue'
 import UsageSettings from '~/components/settings/UsageSettings.vue'
 import WorkspaceMembersSettings from '~/components/layout/WorkspaceMembersSettings.vue'
@@ -29,6 +30,10 @@ const workspace = useWorkspaceStore()
 const access = useWorkspaceAccess()
 const toast = useToast()
 const slots = useReactiveSlots<AppSlots>()
+// Whether the deployment registers any reusable operation at all, hidden or not, so the
+// Operations tab exists only where there is something for it to manage. Not the OFFERED catalog:
+// hiding the last operation would then take away the only screen that un-hides one.
+const taskTypes = useTaskTypesStore()
 
 // The Metadata tab exists only where the deployment DECLARES custom fields — an unwired
 // capability is invisible, not an empty tab in every deployment. Declared-but-malformed fields
@@ -86,6 +91,18 @@ const tabs = computed(() => [
     icon: 'i-lucide-book-open-check',
     slot: 'fragments',
   },
+  // Which of the deployment's reusable operations this board offers. Only where the deployment
+  // registers any: on the stock product the tab would name a catalog that does not exist.
+  ...(taskTypes.hasRegisteredOperations
+    ? [
+        {
+          value: 'operations',
+          label: t('settings.workspaceSettings.tabs.operations'),
+          icon: 'i-lucide-plug',
+          slot: 'operations',
+        },
+      ]
+    : []),
   ...(hasMetadataFields.value
     ? [
         {
@@ -605,6 +622,11 @@ async function save() {
           <ServiceFragmentDefaultsPanel />
         </template>
 
+        <!-- Reusable operations this board offers (only where the deployment registers any) -->
+        <template v-if="taskTypes.hasRegisteredOperations" #operations>
+          <TaskTypeSuppressionsPanel />
+        </template>
+
         <!-- Custom workspace metadata (only where the deployment declares fields) -->
         <template v-if="hasMetadataFields" #metadata>
           <WorkspaceMetadataSettings />

package/app/composables/api/execution.ts

@@ -5,6 +5,8 @@ import {
   getExecutionAgentContextContract,
   getExecutionLlmMetricsContract,
   getExecutionSearchQueriesContract,
+  getExecutionToolCallFailuresContract,
+  getExecutionToolCallsContract,
   getWorkspaceUsageContract,
   mergeBlockContract,
   rejectStepContract,
@@ -165,6 +167,26 @@ export function executionApi({ send, sendWith, ws, pwHeaders }: ApiContext) {
         pathParams: { executionId },
       }),
 
+    // The tool-call trajectory: what the run's agents DID, oldest first. The half of a
+    // failure no model call reports: a tool that errors leaves the call that asked for it
+    // reporting `ok`. Bounded, and says so via `truncated`. Empty when the sink is not wired /
+    // storing is off. The BROWSE read: fetched when the trajectory is opened, since it carries
+    // every argument and result the run captured.
+    getToolCalls: (workspaceId: string, executionId: string) =>
+      send(getExecutionToolCallsContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId },
+      }),
+
+    // The run's failing tool calls plus its exact `{ total, failed }`, counted in SQL rather
+    // than off any list. The panel's headline read, made on open: cheap enough to front the
+    // page, and exact enough that it never disagrees with the debug overview on a long run.
+    getToolCallFailures: (workspaceId: string, executionId: string) =>
+      send(getExecutionToolCallFailuresContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { executionId },
+      }),
+
     // ---- spend safeguard --------------------------------------------------
     resumeSpend: (workspaceId: string) =>
       send(resumeSpendContract, { pathPrefix: ws(workspaceId) }),

package/app/composables/api/taskTypeSuppressions.ts

@@ -0,0 +1,25 @@
+import {
+  listTaskTypeSuppressionsContract,
+  restoreTaskTypeContract,
+  suppressTaskTypeContract,
+} from '@cat-factory/contracts'
+import type { ApiContext } from './context'
+
+/**
+ * Which of the deployment's REUSABLE OPERATIONS this board offers
+ * (`backend/docs/reusable-operations.md`). Every call answers with the WHOLE list, because the
+ * board snapshot's `customTaskTypes` changes with it: hiding one removes it from the picker's own
+ * catalog, so a point response would leave the caller reconciling against data it just invalidated.
+ */
+export function taskTypeSuppressionsApi({ send, ws }: ApiContext) {
+  return {
+    listTaskTypeSuppressions: (workspaceId: string) =>
+      send(listTaskTypeSuppressionsContract, { pathPrefix: ws(workspaceId) }),
+
+    suppressTaskType: (workspaceId: string, taskType: string) =>
+      send(suppressTaskTypeContract, { pathPrefix: ws(workspaceId), pathParams: { taskType } }),
+
+    restoreTaskType: (workspaceId: string, taskType: string) =>
+      send(restoreTaskTypeContract, { pathPrefix: ws(workspaceId), pathParams: { taskType } }),
+  }
+}

package/app/composables/useApi.ts

@@ -4,6 +4,7 @@ import type { ApiContext } from './api/context'
 import { accountsApi } from './api/accounts'
 import { agentPromptsApi } from './api/agentPrompts'
 import { agentSettingsApi } from './api/agentSettings'
+import { taskTypeSuppressionsApi } from './api/taskTypeSuppressions'
 import { platformObservabilityApi } from './api/platformObservability'
 import { reportsApi } from './api/reports'
 import { authApi } from './api/auth'
@@ -144,6 +145,7 @@ export function useApi() {
     ...presetsApi(ctx),
     ...agentPromptsApi(ctx),
     ...agentSettingsApi(ctx),
+    ...taskTypeSuppressionsApi(ctx),
     ...preflightsApi(ctx),
     ...publicApiKeysApi(ctx),
     ...sharedStacksApi(ctx),

package/app/composables/usePipelineHealth.spec.ts

@@ -37,6 +37,7 @@ function scan(
   pipelines: Pipeline[],
   versions: Record<string, number> = {},
   retired: { id: string; replacedBy?: string }[] = [],
+  names: Record<string, string> = {},
 ) {
   const store = usePipelinesStore()
   const retiredIds = new Set(retired.map((r) => r.id))
@@ -46,7 +47,7 @@ function scan(
       ...versions,
     }).filter(([id]) => !retiredIds.has(id)),
   )
-  store.hydrate(pipelines, catalogVersions, retired)
+  store.hydrate(pipelines, catalogVersions, retired, names)
   return usePipelineHealth()
 }
 
@@ -202,6 +203,19 @@ describe('usePipelineHealth', () => {
     expect(outdated.value).toHaveLength(0)
   })
 
+  it("names an un-adopted catalog entry from the catalog's own name map, not its id", () => {
+    // The case that made the humanised fallback wrong: a deployment's registered pipeline behind a
+    // reusable operation. `pl_org_introduce_api` humanises to "org introduce api", a name that
+    // appears nowhere else in the product, and this advisory is shown on exactly the boards that
+    // predate the operation. With the map, the offer reads as the pipeline actually is.
+    const stored = builtin(['coder', 'reviewer'], { id: 'pl_full', version: 1 })
+    const { newPipelines } = scan([stored], { pl_full: 1, pl_org_introduce_api: 1 }, [], {
+      pl_full: 'Full build',
+      pl_org_introduce_api: 'Introduce API',
+    })
+    expect(newPipelines.value).toEqual([{ id: 'pl_org_introduce_api', name: 'Introduce API' }])
+  })
+
   it('reports no new pipelines when every catalog id is already stored', () => {
     const stored = builtin(['coder', 'reviewer'], { id: 'pl_full', version: 1 })
     const { newPipelines, hasIssues } = scan([stored], { pl_full: 1 })

package/app/composables/usePipelineHealth.ts

@@ -57,12 +57,17 @@ export interface NewPipeline {
 }
 
 /**
- * A built-in's display name for the "new pipeline" advisory, humanised from its catalog id
- * (`pl_review` -> "review", rendered capitalised) — used only until the row is reseeded into
- * existence, at which point its real catalog name is stored. Mirrors `useRiskPolicyHealth`.
+ * A catalog entry's display name for the "new pipeline" advisory, used only while the entry has no
+ * stored row to take a name off. The snapshot's companion name map answers it; the humanised id
+ * (`pl_review` -> "review", rendered capitalised) is the FALLBACK for a facade that ships no map.
+ *
+ * The map is not a nicety. Humanising was fine for the shipped built-ins, whose ids read as their
+ * names, and wrong the moment a deployment registers its own: a reusable operation's
+ * `pl_org_introduce_api` was offered as "org introduce api", a name appearing nowhere else in the
+ * product, on exactly the boards that predate the operation and therefore see this advisory.
  */
-function builtinPipelineName(id: string): string {
-  return id.replace(/^pl_/, '').replace(/_/g, ' ')
+function builtinPipelineName(id: string, names: Record<string, string>): string {
+  return names[id] ?? id.replace(/^pl_/, '').replace(/_/g, ' ')
 }
 
 /** Producers a companion kind is allowed to review (inverse of {@link COMPANION_FOR_PRODUCER}). */
@@ -207,7 +212,7 @@ export function usePipelineHealth() {
     const storedIds = new Set(store.pipelines.map((p) => p.id))
     return Object.keys(store.catalogVersions)
       .filter((id) => !storedIds.has(id))
-      .map((id) => ({ id, name: builtinPipelineName(id) }))
+      .map((id) => ({ id, name: builtinPipelineName(id, store.catalogNames) }))
   })
 
   // Retired built-ins this workspace still stores: the ones seeded before the withdrawal. A
@@ -238,7 +243,8 @@ export function usePipelineHealth() {
   function resolveReplacement(id: string): { id: string; name: string } | undefined {
     const stored = store.getPipeline(id)
     if (stored) return { id, name: stored.name }
-    if (id in store.catalogVersions) return { id, name: builtinPipelineName(id) }
+    if (id in store.catalogVersions)
+      return { id, name: builtinPipelineName(id, store.catalogNames) }
     return undefined
   }
 

package/app/docs/consumer-extensions.md

@@ -206,7 +206,13 @@ stray `API delivery` / `API Delivery` pair does not split a category in half.
 
 Your own strings (labels, category captions, descriptions) are rendered verbatim and never enter a
 locale catalog; only the platform's own chrome around them is i18n, which is why the "Other" heading
-is the one caption you do not supply. Each row carries `data-testid="task-type-row"` plus
+is the one caption you do not supply.
+
+**A workspace admin can HIDE any registered type from that board** (Workspace settings → Operations).
+Only backend-REGISTERED types are hideable: a type your frontend module ships as a code
+contribution has no backend row to suppress, so it is offered on every board. If your catalog is
+large enough that teams will want to trim it, register the types on the backend rather than
+contributing them here. Each row carries `data-testid="task-type-row"` plus
 `data-task-type-row="<id>"`, and each choice `data-testid="task-type-<taskType>"`, so your own e2e
 suite can address a row and the caption inside it.
 

package/app/stores/observability/toolCalls.ts

@@ -0,0 +1,173 @@
+import { ref } from 'vue'
+import type { RunToolCallFailures, RunToolCallTrajectory } from '~/types/execution'
+
+// The observability store's TOOL-CALL sink, extracted whole because it is one concern with two
+// reads and its own coherence rule between them.
+//
+// The rule: the two reads answer at DIFFERENT BOUNDS and must never be mistaken for each other.
+// `failures` is about the run — counts aggregated in SQL over every row it ever wrote. The
+// trajectory is a bounded PREFIX of the run, carrying every captured argument and result, which
+// is why it is loaded on demand rather than on open. Anything that counts, judges or headlines
+// reads the first; only the browse view reads the second, and it renders under a flag saying so.
+//
+// Keeping that pairing in one module is the point of the split: a caller reaching for whichever
+// list is nearest is exactly how a panel ends up reporting a long run's opening moves as
+// everything it did.
+
+/** What the sink needs from the API layer: the two reads, already bound to a workspace. */
+export interface ToolCallSinkDeps {
+  /**
+   * Whether a workspace is resolved yet.
+   *
+   * Checked BEFORE either read rather than left to the binding throwing, because these loads
+   * record their failures as "this sink did not answer" — a state the panel reports to an
+   * operator — and "no workspace selected yet" is not that. It is nobody having asked.
+   */
+  ready: () => boolean
+  fetchTrajectory: (executionId: string) => Promise<RunToolCallTrajectory & { executionId: string }>
+  fetchFailures: (executionId: string) => Promise<RunToolCallFailures & { executionId: string }>
+}
+
+/**
+ * What {@link ToolCallSinkState.toolCallsFor} answers for a run that was never loaded.
+ *
+ * A frozen shared value rather than a fresh object per call: this is read inside computeds, and a
+ * new identity on every evaluation re-triggers every one of them downstream.
+ */
+export const EMPTY_TRAJECTORY: RunToolCallTrajectory = Object.freeze({
+  toolCalls: Object.freeze([]) as never,
+  truncated: false,
+})
+
+/** Add or remove a key from a reactive `Set` ref, replacing it so the reactivity fires. */
+function withFlag(set: ReturnType<typeof ref<Set<string>>>, key: string, on: boolean) {
+  const next = new Set(set.value)
+  if (on) next.add(key)
+  else next.delete(key)
+  set.value = next
+}
+
+export function createToolCallSinkState(deps: ToolCallSinkDeps) {
+  /**
+   * Per-execution-id trajectory PREFIX (oldest first, the order the agent worked in) with the
+   * flag saying whether the run made more calls than it holds.
+   */
+  const toolCallsByExecution = ref<Record<string, RunToolCallTrajectory>>({})
+  /** Execution ids whose trajectory is currently loading. */
+  const toolCallsLoading = ref<Set<string>>(new Set())
+  /**
+   * Last trajectory-load error per execution id, or null. Recorded for the same reason the
+   * context load records its own: a swallowed failure would render as the "no tool calls
+   * recorded" empty state, which on this sink is a claim rather than a blank tab.
+   */
+  const toolCallErrors = ref<Record<string, string | null>>({})
+  /**
+   * Per-execution-id FAILING tool calls plus the run's exact counts.
+   *
+   * Separate from the trajectory because the numbers here are SQL aggregates over the whole run
+   * while that list is a bounded prefix of it. Counting failures off the prefix is how a panel
+   * ends up printing "nothing failed" over a run whose failures came after its opening moves.
+   */
+  const toolCallFailuresByExecution = ref<Record<string, RunToolCallFailures>>({})
+  /** Execution ids whose failure summary is currently loading. */
+  const toolCallFailuresLoading = ref<Set<string>>(new Set())
+  /**
+   * Last failure-summary load error per execution id, or null.
+   *
+   * The one error state the panel cannot afford to swallow: this read is what the pinned "what
+   * failed" section speaks from, so a failure here has to reach it as "this sink did not answer"
+   * rather than as the zero rows it would otherwise be indistinguishable from.
+   */
+  const toolCallFailureErrors = ref<Record<string, string | null>>({})
+
+  /**
+   * The loaded trajectory prefix, or the empty one.
+   *
+   * `truncated: false` on a run that was never loaded is not a claim that the run is short: a
+   * caller distinguishes the two through {@link hasToolCalls}, never by finding this empty.
+   */
+  function toolCallsFor(executionId: string): RunToolCallTrajectory {
+    return toolCallsByExecution.value[executionId] ?? EMPTY_TRAJECTORY
+  }
+  function isToolCallsLoading(executionId: string): boolean {
+    return toolCallsLoading.value.has(executionId)
+  }
+  /** Whether the trajectory has ever been loaded for this run (an empty answer still counts). */
+  function hasToolCalls(executionId: string): boolean {
+    return executionId in toolCallsByExecution.value
+  }
+
+  /** Load (or refresh) the tool-call trajectory for a run. */
+  async function loadToolCalls(executionId: string) {
+    if (!deps.ready()) return
+    withFlag(toolCallsLoading, executionId, true)
+    toolCallErrors.value = { ...toolCallErrors.value, [executionId]: null }
+    try {
+      const { toolCalls, truncated } = await deps.fetchTrajectory(executionId)
+      toolCallsByExecution.value = {
+        ...toolCallsByExecution.value,
+        [executionId]: { toolCalls, truncated },
+      }
+    } catch (err) {
+      toolCallErrors.value = {
+        ...toolCallErrors.value,
+        [executionId]: err instanceof Error ? err.message : 'Failed to load tool calls',
+      }
+    } finally {
+      withFlag(toolCallsLoading, executionId, false)
+    }
+  }
+
+  /** The loaded failure summary, or null when this run's has not answered (yet, or at all). */
+  function toolCallFailuresFor(executionId: string): RunToolCallFailures | null {
+    return toolCallFailuresByExecution.value[executionId] ?? null
+  }
+  function isToolCallFailuresLoading(executionId: string): boolean {
+    return toolCallFailuresLoading.value.has(executionId)
+  }
+
+  /**
+   * Load (or refresh) the run's failing tool calls and exact counts.
+   *
+   * Cleared on failure rather than left holding the previous answer: a stale summary beside a
+   * fresh error would let the panel keep asserting a failure count the backend just refused to
+   * confirm.
+   */
+  async function loadToolCallFailures(executionId: string) {
+    if (!deps.ready()) return
+    withFlag(toolCallFailuresLoading, executionId, true)
+    toolCallFailureErrors.value = { ...toolCallFailureErrors.value, [executionId]: null }
+    try {
+      const { total, failed, failures, failuresTruncated } = await deps.fetchFailures(executionId)
+      toolCallFailuresByExecution.value = {
+        ...toolCallFailuresByExecution.value,
+        [executionId]: { total, failed, failures, failuresTruncated },
+      }
+    } catch (err) {
+      const { [executionId]: _dropped, ...rest } = toolCallFailuresByExecution.value
+      toolCallFailuresByExecution.value = rest
+      toolCallFailureErrors.value = {
+        ...toolCallFailureErrors.value,
+        [executionId]: err instanceof Error ? err.message : 'Failed to load tool-call failures',
+      }
+    } finally {
+      withFlag(toolCallFailuresLoading, executionId, false)
+    }
+  }
+
+  return {
+    toolCallsByExecution,
+    toolCallErrors,
+    toolCallsFor,
+    hasToolCalls,
+    isToolCallsLoading,
+    loadToolCalls,
+    toolCallFailuresByExecution,
+    toolCallFailureErrors,
+    toolCallFailuresFor,
+    isToolCallFailuresLoading,
+    loadToolCallFailures,
+  }
+}
+
+export type ToolCallSinkState = ReturnType<typeof createToolCallSinkState>

package/app/stores/observability.ts

@@ -7,6 +7,7 @@ import type {
   LlmCallMetric,
 } from '~/types/execution'
 import { useWorkspaceStore } from '~/stores/workspace'
+import { createToolCallSinkState } from '~/stores/observability/toolCalls'
 
 /**
  * LLM observability state: the full per-call model activity for a run (prompts,
@@ -22,6 +23,17 @@ export const useObservabilityStore = defineStore('observability', () => {
   const api = useApi()
   const workspace = useWorkspaceStore()
 
+  /**
+   * The TOOL-CALL sink, extracted whole: two reads at two different bounds, plus the rule that
+   * keeps them apart (see `observability/toolCalls.ts`). The store owns the workspace binding and
+   * nothing else about it.
+   */
+  const toolCalls = createToolCallSinkState({
+    ready: () => !!workspace.workspaceId,
+    fetchTrajectory: (executionId) => api.getToolCalls(workspace.requireId(), executionId),
+    fetchFailures: (executionId) => api.getToolCallFailures(workspace.requireId(), executionId),
+  })
+
   /** Per-execution-id call list (newest first). */
   const callsByExecution = ref<Record<string, LlmCallMetric[]>>({})
   /** Per-execution-id provided-context snapshot list (newest first). */
@@ -223,5 +235,6 @@ export const useObservabilityStore = defineStore('observability', () => {
     searchQueriesFor,
     isSearchQueriesLoading,
     loadSearchQueries,
+    ...toolCalls,
   }
 })

package/app/stores/pipelines.ts

@@ -32,6 +32,13 @@ export const usePipelinesStore = defineStore('pipelines', () => {
    * a newer definition available (see `usePipelineHealth`).
    */
   const catalogVersions = ref<Record<string, number>>({})
+  /**
+   * The catalog's own NAME per id in {@link catalogVersions}, from the same snapshot field pair.
+   * Read only where a catalog entry has no stored row to take a name off (the "new built-ins"
+   * advisory and the replacement a retirement points at); everywhere else the stored row's authored
+   * name is the answer. Empty for a facade that ships no name map.
+   */
+  const catalogNames = ref<Record<string, string>>({})
   /**
    * Built-in pipelines WITHDRAWN from the catalog (`retiredPipelines()`), from the workspace
    * snapshot. A stored pipeline whose id appears here is no longer relevant and can be REMOVED —
@@ -75,18 +82,27 @@ export const usePipelinesStore = defineStore('pipelines', () => {
   const editingId = ref<string | null>(null)
 
   /**
-   * Replace the cached pipelines (and the current built-in catalog versions + retirements) from a
-   * snapshot. `retired` is applied even when EMPTY, unlike `versions`: an absent list means the
-   * facade shipped no retirements, and carrying the previous board's forward would offer a delete
-   * for a pipeline this deployment still ships.
+   * Replace the cached pipelines (and the current built-in catalog versions + names +
+   * retirements) from a snapshot. `retired` is applied even when EMPTY, unlike `versions`: an
+   * absent list means the facade shipped no retirements, and carrying the previous board's forward
+   * would offer a delete for a pipeline this deployment still ships. `names` rides `versions`,
+   * being the other half of one read.
    */
   function hydrate(
     next: Pipeline[],
     versions?: Record<string, number>,
     retired?: RetiredPipelineWire[],
+    names?: Record<string, string>,
   ) {
     pipelines.value = next
-    if (versions) catalogVersions.value = versions
+    // The two catalog maps move TOGETHER, because they are one snapshot read split in two and are
+    // keyed identically by construction. Assigning names on their own truthiness would let a
+    // facade that ships versions and no names leave the previous board's names indexed against
+    // this board's ids, which is the one way the pair can disagree.
+    if (versions) {
+      catalogVersions.value = versions
+      catalogNames.value = names ?? {}
+    }
     retiredPipelines.value = retired ?? []
   }
 
@@ -133,6 +149,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
   return {
     pipelines,
     catalogVersions,
+    catalogNames,
     retiredPipelines,
     gateConfigForms,
     draft,

package/app/stores/taskTypes.spec.ts

@@ -86,6 +86,35 @@ describe('taskTypes store — custom task-type catalog (extension slice B)', ()
     expect(isKnownTaskType('acme:ws1')).toBe(false)
   })
 
+  it('still reports registered operations when the board has hidden every one of them', () => {
+    // The regression this exists for: the workspace-settings Operations tab was gated on the
+    // OFFERED catalog, which suppression empties. Hiding the last operation therefore removed the
+    // only screen that un-hides one, and nothing failed: the tab simply was not there.
+    const store = useTaskTypesStore()
+    expect(store.hasRegisteredOperations).toBe(false)
+
+    hydrate(store, [backendType('acme:kept'), backendType('acme:hidden')])
+    store.hydrateSuppressed([])
+    expect(store.hasRegisteredOperations).toBe(true)
+
+    // Every registered operation hidden: the offered catalog is empty and the screen must remain.
+    hydrate(store, [])
+    store.hydrateSuppressed(['acme:kept', 'acme:hidden'])
+    expect(store.customTaskTypes).toEqual([])
+    expect(store.hasRegisteredOperations).toBe(true)
+  })
+
+  it('drops the previous board’s suppressions on re-hydrate (per-workspace state)', () => {
+    // Assigned unconditionally rather than on truthiness: carrying a hidden list forward would
+    // leave the Operations tab standing on a board that registers nothing.
+    const store = useTaskTypesStore()
+    hydrate(store, [])
+    store.hydrateSuppressed(['acme:ws1'])
+    expect(store.hasRegisteredOperations).toBe(true)
+    store.hydrateSuppressed([])
+    expect(store.hasRegisteredOperations).toBe(false)
+  })
+
   it('get() returns the full registration (for the create-form field descriptors)', () => {
     const store = useTaskTypesStore()
     hydrate(store, [