@cat-factory/app 0.147.6 → 0.148.1

package/app/components/board/AddTaskModal.vue

@@ -21,6 +21,9 @@ import type {
   TaskTypeFields,
 } from '~/types/domain'
 import { DOC_KINDS, DOC_KIND_FIELDS } from '~/types/domain'
+import { resolveComponentRegistry } from '@modular-vue/core'
+import { useReactiveSlots } from '@modular-vue/runtime'
+import type { AppSlots, ResultViewContribution } from '~/modular/slots'
 import ContextDocumentPicker from '~/components/documents/ContextDocumentPicker.vue'
 import ContextIssuePicker from '~/components/tasks/ContextIssuePicker.vue'
 import FragmentSelector from '~/components/fragments/FragmentSelector.vue'
@@ -131,6 +134,54 @@ const reviewFocus = ref('')
 const fragmentIds = ref<string[]>([])
 const isReview = computed(() => taskType.value === 'review')
 
+// Custom (deployment-registered) task types — the frontend-extension-mechanism slice B twin of
+// custom agent kinds. The task-types store merges CODE-shipped (`taskTypes` slot) + BACKEND
+// (snapshot `customTaskTypes`) into one catalog; the picker offers them alongside the built-ins.
+// A document repo only accepts document/spike (server-rejected otherwise), so custom types are
+// hidden there — mirroring the built-in `isDocRepo` filter.
+const taskTypesStore = useTaskTypesStore()
+const customTaskTypes = computed(() => (isDocRepo.value ? [] : taskTypesStore.customTaskTypes))
+const selectedCustomType = computed(() =>
+  customTaskTypes.value.find((tt) => tt.taskType === taskType.value),
+)
+// Descriptor-field values for a selected custom type (or a bespoke form panel's own bag), folded
+// into `taskTypeFields.custom` on submit. Cleared when the type changes / the modal reopens.
+const customFieldValues = ref<Record<string, string | number>>({})
+// A bespoke create-form section paired to the custom type's `formPanel` id via the
+// `taskTypeFormPanels` slot; shown INSTEAD of the descriptor fields. Unpaired ⇒ descriptor fields
+// (degrade, never crash) — the same pairing shape as the result-view windows.
+const appSlots = useReactiveSlots<AppSlots>()
+const formPanelRegistry = computed(() =>
+  resolveComponentRegistry((appSlots.value.taskTypeFormPanels ?? []) as ResultViewContribution[]),
+)
+const customFormPanel = computed(() => {
+  const id = selectedCustomType.value?.formPanel
+  return id ? (formPanelRegistry.value.get(id) ?? null) : null
+})
+// Whether every REQUIRED descriptor field of the selected custom type has a value. Only the
+// descriptor path is enforced up front — a bespoke `formPanel` owns its own validation, so we
+// don't block on it (nor can we read its required semantics). No custom type selected (or none
+// of its fields are required) ⇒ trivially satisfied. Folded into `canAdd` so the required marker
+// the form renders is actually honoured before submit.
+const customRequiredFieldsFilled = computed(() => {
+  const custom = selectedCustomType.value
+  if (!custom || customFormPanel.value) return true
+  return (custom.fields ?? []).every((field) => {
+    if (!field.required) return true
+    const raw = customFieldValues.value[field.key]
+    return raw !== undefined && String(raw).trim() !== ''
+  })
+})
+// The type picker: the built-in choices (i18n labels) + the custom types (their wire presentation).
+const typeChoices = computed<{ value: TaskTypeChoice; label: string; icon: string }[]>(() => [
+  ...TASK_TYPES.value,
+  ...customTaskTypes.value.map((tt) => ({
+    value: tt.taskType as TaskTypeChoice,
+    label: tt.presentation.label,
+    icon: tt.presentation.icon,
+  })),
+])
+
 // Parse the PR-reference input into the contract fields: a bare positive integer (optionally
 // `#`-prefixed) becomes `prNumber` (a PR on the service's linked repo); anything else is taken
 // as a full URL (`prUrl`). Returns undefined when blank or unparseable — the caller uses that
@@ -196,6 +247,33 @@ const DOC_FIELD_PLACEHOLDER_KEYS: Record<DocKindFieldKey, string> = {
 }
 const SEVERITIES = ['low', 'medium', 'high', 'critical'] as const
 
+// A CUSTOM (deployment-registered) task type: fold the collected values into the sparse
+// `taskTypeFields.custom` bag. A bespoke form panel owns the whole bag (taken verbatim); the
+// descriptor path reads only the declared fields, coercing a `number` descriptor's string input.
+function buildCustomTypeFields(): TaskTypeFields | undefined {
+  const custom = selectedCustomType.value
+  if (!custom) return undefined
+  const bag: Record<string, string | number> = {}
+  if (customFormPanel.value) {
+    for (const [key, value] of Object.entries(customFieldValues.value)) {
+      if (value !== undefined && value !== '') bag[key] = value
+    }
+  } else {
+    for (const field of custom.fields ?? []) {
+      const raw = customFieldValues.value[field.key]
+      if (raw === undefined || raw === '') continue
+      if (field.type === 'number') {
+        // Skip a non-numeric value rather than sending NaN (which serialises to null on the wire).
+        const n = Number(raw)
+        if (Number.isFinite(n)) bag[field.key] = n
+      } else {
+        bag[field.key] = raw
+      }
+    }
+  }
+  return Object.keys(bag).length ? { custom: bag } : undefined
+}
+
 function buildTypeFields(): TaskTypeFields | undefined {
   if (taskType.value === 'bug') {
     const f: TaskTypeFields = {}
@@ -238,7 +316,7 @@ function buildTypeFields(): TaskTypeFields | undefined {
     if (reviewFocus.value.trim()) f.reviewFocus = reviewFocus.value.trim()
     return Object.keys(f).length ? f : undefined
   }
-  return undefined
+  return buildCustomTypeFields()
 }
 
 // For a recurring task, the schedule attaches to the service frame: the container itself
@@ -346,7 +424,13 @@ const DEFAULT_PIPELINE_FOR_TYPE: Partial<Record<TaskTypeChoice, string>> = {
   review: 'pl_review',
 }
 watch(taskType, (next) => {
-  const preset = DEFAULT_PIPELINE_FOR_TYPE[next]
+  // A custom type owns a fresh field bag on every switch (its descriptors differ per type).
+  customFieldValues.value = {}
+  // Pre-select the type's default pipeline: a custom type's registered `defaultPipelineId`, else
+  // the built-in map. (For a custom type with no default, `BoardService` applies the registry
+  // default at creation, so leaving the picker unset is fine.)
+  const custom = customTaskTypes.value.find((tt) => tt.taskType === next)
+  const preset = custom?.defaultPipelineId ?? DEFAULT_PIPELINE_FOR_TYPE[next]
   if (!preset) return
   const match = pipelines.pipelines.find((p) => p.id === preset)
   if (match) pipelineId.value = match.id
@@ -502,6 +586,7 @@ watch(open, (isOpen) => {
   docOutlineHints.value = ''
   reviewPrRef.value = ''
   reviewFocus.value = ''
+  customFieldValues.value = {}
   // Pre-seed the best-practice fragments from the enclosing service's standards, so a new task
   // ships with its service's fragments already selected (and freely add/removable here). The task
   // OWNS this selection from creation — the engine folds exactly these, without re-unioning the
@@ -587,6 +672,8 @@ const canAdd = computed(() => {
     configValue(RALPH_VALIDATION_COMMAND_ID, '').trim().length === 0
   )
     return false
+  // A custom type's required descriptor fields must be filled (its form renders them as required).
+  if (!customRequiredFieldsFilled.value) return false
   return true
 })
 
@@ -667,12 +754,13 @@ async function add() {
         <UFormField :label="t('board.addTask.typeLabel')">
           <div class="flex flex-wrap gap-1">
             <UButton
-              v-for="ty in TASK_TYPES"
+              v-for="ty in typeChoices"
               :key="ty.value"
               :color="taskType === ty.value ? 'primary' : 'neutral'"
               :variant="taskType === ty.value ? 'soft' : 'ghost'"
               :icon="ty.icon"
               size="xs"
+              :data-testid="`task-type-${ty.value}`"
               @click="
                 () => {
                   taskType = ty.value
@@ -949,6 +1037,61 @@ async function add() {
             </UFormField>
           </div>
 
+          <!-- A CUSTOM (deployment-registered) task type: a bespoke create-form section when its
+               `formPanel` is paired to the `taskTypeFormPanels` slot, else the descriptor-driven
+               `fields` the type declares. None of the built-in `v-if` branches above match a
+               namespaced custom type, so this renders on its own. -->
+          <div v-if="selectedCustomType" class="space-y-3" data-testid="custom-task-fields">
+            <component
+              :is="customFormPanel"
+              v-if="customFormPanel"
+              :task-type="selectedCustomType"
+              :model-value="customFieldValues"
+              @update:model-value="customFieldValues = $event"
+            />
+            <template v-else>
+              <UFormField
+                v-for="field in selectedCustomType.fields ?? []"
+                :key="field.key"
+                :label="field.label"
+                :help="field.help"
+                :required="field.required"
+              >
+                <div v-if="field.type === 'select'" class="flex flex-wrap gap-1">
+                  <UButton
+                    v-for="opt in field.options ?? []"
+                    :key="opt.value"
+                    :color="customFieldValues[field.key] === opt.value ? 'primary' : 'neutral'"
+                    :variant="customFieldValues[field.key] === opt.value ? 'soft' : 'ghost'"
+                    size="xs"
+                    :data-testid="`custom-field-${field.key}-${opt.value}`"
+                    @click="() => (customFieldValues[field.key] = opt.value)"
+                  >
+                    {{ opt.label }}
+                  </UButton>
+                </div>
+                <UTextarea
+                  v-else-if="field.type === 'textarea'"
+                  v-model="customFieldValues[field.key]"
+                  :rows="2"
+                  :maxlength="field.maxLength"
+                  :placeholder="field.placeholder"
+                  :data-testid="`custom-field-${field.key}`"
+                  class="w-full"
+                />
+                <UInput
+                  v-else
+                  v-model="customFieldValues[field.key]"
+                  :type="field.type === 'number' ? 'number' : 'text'"
+                  :maxlength="field.maxLength"
+                  :placeholder="field.placeholder"
+                  :data-testid="`custom-field-${field.key}`"
+                  class="w-full"
+                />
+              </UFormField>
+            </template>
+          </div>
+
           <div class="grid grid-cols-2 gap-3">
             <UFormField :label="t('board.addTask.pipeline')">
               <PipelinePicker

package/app/components/board/nodes/TaskCard.vue

@@ -1,6 +1,6 @@
 <script setup lang="ts">
 import type { Block } from '~/types/domain'
-import { STATUS_META, MODULE_META } from '~/utils/catalog'
+import { STATUS_META, MODULE_META, taskTypeMeta } from '~/utils/catalog'
 import AgentFailureCard from '~/components/board/AgentFailureCard.vue'
 import TaskPipelineMini from './TaskPipelineMini.vue'
 
@@ -18,6 +18,22 @@ const { confirm } = useConfirm()
 
 const task = computed<Block | undefined>(() => board.getBlock(props.taskId))
 const statusMeta = computed(() => (task.value ? STATUS_META[task.value.status] : null))
+
+// A type badge for any NON-default task type — built-in (bug/document/spike/review/ralph) or a
+// deployment CUSTOM type (resolved through the `taskTypeMeta` read-model, which degrades an
+// unregistered namespaced type to the `feature` presentation, so a stale id never breaks the card).
+// `feature` is the implicit default and shows no badge to keep ordinary cards uncluttered. A
+// built-in type's label is an i18n key; a custom type's is a literal from its wire presentation.
+const typeBadge = computed(() => {
+  const tt = task.value?.taskType
+  if (!tt || tt === 'feature') return null
+  const meta = taskTypeMeta(tt)
+  return {
+    icon: meta.icon,
+    color: meta.color,
+    label: meta.labelKey ? t(meta.labelKey) : (meta.label ?? tt),
+  }
+})
 const selected = computed(() => ui.selectedBlockId === props.taskId)
 
 // Drag-to-connect: dragging from this card's handle onto another task makes THAT task
@@ -215,6 +231,18 @@ function selectTask() {
          on its own row rather than stealing horizontal space from the title. -->
     <div class="flex items-center gap-1.5">
       <span class="h-2 w-2 shrink-0 rounded-full" :style="{ backgroundColor: statusMeta.color }" />
+      <!-- Task-type badge (non-`feature` only): the type's icon, tinted with its accent, label on
+           hover. Renders a built-in OR a deployment-registered custom type via `taskTypeMeta`. -->
+      <span
+        v-if="typeBadge"
+        class="inline-flex h-3.5 w-3.5 shrink-0 items-center justify-center rounded"
+        :style="{ color: typeBadge.color, backgroundColor: `${typeBadge.color}22` }"
+        :title="typeBadge.label"
+        :data-task-type-badge="task.taskType"
+        data-testid="task-type-badge"
+      >
+        <UIcon :name="typeBadge.icon" class="h-2.5 w-2.5" />
+      </span>
       <UIcon
         v-if="schedule"
         name="i-lucide-repeat"

package/app/components/settings/WorkspaceSettingsPanel.vue

@@ -8,7 +8,7 @@
 // The latter three are body-only section components rendered in tabs here (no longer
 // standalone modals).
 import { reactive, ref, watch } from 'vue'
-import type { CreateTaskType, TaskLimitMode } from '~/types/domain'
+import type { TaskLimitMode } from '~/types/domain'
 import RiskPolicyPanel from '~/components/settings/RiskPolicyPanel.vue'
 import IssueTrackerPanel from '~/components/settings/IssueTrackerPanel.vue'
 import ServiceFragmentDefaultsPanel from '~/components/settings/ServiceFragmentDefaultsPanel.vue'
@@ -103,12 +103,18 @@ const tabsUi = {
   indicator: 'hidden',
 }
 
-const TASK_TYPES: CreateTaskType[] = ['feature', 'bug', 'document', 'spike']
+// The finite BUILT-IN create-task types this per-type running-task-limit UI configures.
+// `CreateTaskType` widened to an open `string` (to admit consumer-registered CUSTOM task types),
+// so the config surface pins the built-in set it renders inputs for — a custom type buckets on its
+// own id server-side (`RunAdmission`) and is not configured here. Keying the records below off this
+// finite union (not the open `CreateTaskType`) keeps them exhaustive + undefined-free.
+type LimitTaskType = 'feature' | 'bug' | 'document' | 'spike' | 'review' | 'ralph'
+const TASK_TYPES: LimitTaskType[] = ['feature', 'bug', 'document', 'spike']
 
 // Per-task-type label for the "Max {type} tasks" inputs. An exhaustive Record keyed off
-// the CreateTaskType union (a missing member fails the typecheck); each value is a LITERAL
-// catalog key so the typed-message-keys check sees it. Leaf keys mirror the enum verbatim.
-const TASK_TYPE_KEYS: Record<CreateTaskType, string> = {
+// the finite {@link LimitTaskType} union (a missing member fails the typecheck); each value is a
+// LITERAL catalog key so the typed-message-keys check sees it. Leaf keys mirror the enum verbatim.
+const TASK_TYPE_KEYS: Record<LimitTaskType, string> = {
   feature: 'settings.workspaceSettings.taskTypes.feature',
   bug: 'settings.workspaceSettings.taskTypes.bug',
   document: 'settings.workspaceSettings.taskTypes.document',
@@ -124,7 +130,7 @@ const MODES = computed<{ value: TaskLimitMode; label: string }[]>(() => [
 ])
 
 /** The localized "Max {type} tasks" label for a per-type running-task limit input. */
-function maxTaskTypeLabel(type: CreateTaskType): string {
+function maxTaskTypeLabel(type: LimitTaskType): string {
   const key = TASK_TYPE_KEYS[type]
   const typeLabel = te(key) ? t(key) : type
   return t('settings.workspaceSettings.taskLimit.maxPerType', { type: typeLabel })
@@ -135,7 +141,7 @@ const draft = reactive({
   waitingEscalationMinutes: 120,
   taskLimitMode: 'off' as TaskLimitMode,
   taskLimitShared: 5 as number,
-  perType: {} as Record<CreateTaskType, number>,
+  perType: {} as Record<LimitTaskType, number>,
   storeAgentContext: true,
   artifactRetentionDays: 14,
   kaizenEnabled: true,
@@ -173,7 +179,7 @@ async function save() {
                 acc[t] = draft.perType[t]
                 return acc
               },
-              {} as Record<CreateTaskType, number>,
+              {} as Record<LimitTaskType, number>,
             )
           : null,
       storeAgentContext: draft.storeAgentContext,

package/app/docs/consumer-extensions.md

@@ -62,14 +62,15 @@ export default defineNuxtPlugin(() => {
 
 ## The landed seams
 
-| Seam                                | Slot key          | Entry shape                                                                                      | Host                                        |
-| ----------------------------------- | ----------------- | ------------------------------------------------------------------------------------------------ | ------------------------------------------- |
-| Run-detail windows                  | `resultViews`     | `{ id: '<ns>:<name>', component }`                                                               | `StepResultViewHost` via `dispatchStepView` |
-| Agent kinds (palette data)          | `agentKinds`      | `{ kind, container, presentation: { label, icon, color, description, category?, resultView? } }` | agents store merge → `agentKindMeta`        |
-| Sidebar / command-palette / toolbar | `nav`             | `{ id, labelKey, icon, surfaces, gate?, run, sidebar?, command?, toolbar? }`                     | the three shells via `useNavContributions`  |
-| Inspector body panels               | `inspectorPanels` | `{ id, component, when(block), order }` (`PanelEntry<Block>`)                                    | `<PanelsOutlet>` in `InspectorPanel`        |
-| Multi-step wizards                  | (journeys)        | `registerJourney` + step modules                                                                 | `<JourneyHost>` / `<JourneyOutlet>`         |
-| Locale strings                      | (i18n)            | `i18n/locales/*.json` in the deployment                                                          | `@nuxtjs/i18n` layer deep-merge             |
+| Seam                                | Slot key          | Entry shape                                                                                      | Host                                                                 |
+| ----------------------------------- | ----------------- | ------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------- |
+| Run-detail windows                  | `resultViews`     | `{ id: '<ns>:<name>', component }`                                                               | `StepResultViewHost` via `dispatchStepView`                          |
+| Agent kinds (palette data)          | `agentKinds`      | `{ kind, container, presentation: { label, icon, color, description, category?, resultView? } }` | agents store merge → `agentKindMeta`                                 |
+| Custom task types                   | `taskTypes`       | `{ taskType: '<ns>:<name>', presentation, fields?, defaultPipelineId?, formPanel? }`             | `AddTaskModal` picker/fields + `TaskCard` badge (via `taskTypeMeta`) |
+| Sidebar / command-palette / toolbar | `nav`             | `{ id, labelKey, icon, surfaces, gate?, run, sidebar?, command?, toolbar? }`                     | the three shells via `useNavContributions`                           |
+| Inspector body panels               | `inspectorPanels` | `{ id, component, when(block), order }` (`PanelEntry<Block>`)                                    | `<PanelsOutlet>` in `InspectorPanel`                                 |
+| Multi-step wizards                  | (journeys)        | `registerJourney` + step modules                                                                 | `<JourneyHost>` / `<JourneyOutlet>`                                  |
+| Locale strings                      | (i18n)            | `i18n/locales/*.json` in the deployment                                                          | `@nuxtjs/i18n` layer deep-merge                                      |
 
 ### Run-detail windows (`resultViews` + `agentKinds`)
 
@@ -102,6 +103,38 @@ show the panel, and `order` places it among the built-ins. Your panel component
 selected block via `usePanelSubject<Block>()` (`@modular-vue/core`). `when` must tolerate a
 nullish subject (the boot-time validation resolve passes `null`).
 
+### Custom task types (`taskTypes`)
+
+Model a proprietary work item — an "incident", "pentest", "compliance-audit" — as a first-class
+task type, the create-task twin of an agent kind. Contribute `{ taskType: '<ns>:<name>',
+presentation: { label, icon, color, description }, fields?, defaultPipelineId?, formPanel? }` to
+the `taskTypes` slot (see `acme:incident` in the example module). The SPA merges it into the
+create-task picker and the card-badge catalog:
+
+- **`presentation`** drives the create-task picker entry and the `TaskCard` type badge (resolved
+  through the pure `taskTypeMeta` read-model — the `agentKindMeta` twin). An UNREGISTERED
+  namespaced type (a stale row after your extension is removed) degrades to the `feature`
+  presentation, so a leftover string never breaks a card.
+- **`fields`** are descriptor-driven create-form inputs (`text` / `textarea` / `number` /
+  `select`); their values land in the task's sparse `taskTypeFields.custom` bag (no migration).
+- **`formPanel`** optionally names a bespoke create-form section component you contribute to the
+  `taskTypeFormPanels` slot (paired by that id, like `resultViews`); shown INSTEAD of `fields`. An
+  unpaired id degrades to the descriptor fields.
+- **`defaultPipelineId`** pre-selects the type's pipeline in the picker.
+
+The **same type can be delivered from the backend** instead of code-shipped: register it on the
+deployment's app-owned `TaskTypeRegistry` and it arrives in the workspace snapshot's
+`customTaskTypes`, folded into the SAME merged catalog (data over the wire, never components). The
+widened `taskType` contract (`<built-in> | <ns>:<name>`) accepts the namespaced id everywhere, so a
+task created with it round-trips with zero host edits.
+
+> **Validation.** A BACKEND-registered task type is checked at boot by `validateRegistrations`
+> (namespaced id, well-formed `formPanel`, a `defaultPipelineId` that resolves to a real pipeline).
+> A CODE-shipped `taskTypes` entry is trusted and **not** validated (like a code-shipped agent kind):
+> a malformed `taskType`/`formPanel` id or a `defaultPipelineId` naming no real pipeline fails
+> silently — the type just won't pre-select a pipeline and an unpaired `formPanel` degrades to the
+> descriptor `fields`. Prefer backend registration when you want the fail-fast guardrail.
+
 ## Reuse the shared building blocks — don't reinvent them
 
 The layer ships window/inspector primitives you compose instead of hand-rolling chrome or

package/app/modular/agent-kinds.spec.ts

@@ -1,10 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import {
-  buildAgentCapabilitiesManifest,
-  capabilitiesManifestVersion,
-  customKindToArchetype,
-  WORKSPACE_CAPABILITIES_MANIFEST_ID,
-} from './agent-kinds'
+import { customKindToArchetype } from './agent-kinds'
 import type { AgentKind, CustomAgentKind } from '~/types/domain'
 
 const kind = (
@@ -22,39 +17,6 @@ const kind = (
   },
 })
 
-describe('buildAgentCapabilitiesManifest', () => {
-  it('models the snapshot kinds as one remote capability manifest carrying the agentKinds slot', () => {
-    const kinds = [kind(), kind()]
-    const manifest = buildAgentCapabilitiesManifest(kinds)
-    expect(manifest.id).toBe(WORKSPACE_CAPABILITIES_MANIFEST_ID)
-    expect(manifest.slots?.agentKinds).toEqual(kinds)
-  })
-
-  it('copies the input (no aliasing of the caller array)', () => {
-    const kinds = [kind()]
-    const manifest = buildAgentCapabilitiesManifest(kinds)
-    kinds.push(kind())
-    expect(manifest.slots?.agentKinds).toHaveLength(1)
-  })
-
-  it('derives an identical version for identical content (so an unchanged re-hydrate no-ops)', () => {
-    // A fresh, structurally-equal kinds array (a new snapshot re-delivering the same kinds)
-    // must produce the same version — that's what lets `hydrateCustomKinds` skip the swap.
-    expect(buildAgentCapabilitiesManifest([kind()]).version).toBe(
-      buildAgentCapabilitiesManifest([kind()]).version,
-    )
-  })
-
-  it('changes the version when a display/pairing field or the kind set differs', () => {
-    const base = capabilitiesManifestVersion([kind()])
-    expect(capabilitiesManifestVersion([kind({ label: 'Renamed' })])).not.toBe(base)
-    expect(capabilitiesManifestVersion([kind({ resultView: 'acme:audit' })])).not.toBe(base)
-    expect(capabilitiesManifestVersion([kind({}, 'acme-other')])).not.toBe(base)
-    expect(capabilitiesManifestVersion([kind(), kind({}, 'acme-two')])).not.toBe(base)
-    expect(capabilitiesManifestVersion([])).not.toBe(base)
-  })
-})
-
 describe('customKindToArchetype', () => {
   it('projects presentation onto the display archetype', () => {
     expect(customKindToArchetype(kind())).toEqual({

package/app/modular/agent-kinds.ts

@@ -1,67 +1,16 @@
-import type { RemoteModuleManifest } from '@modular-vue/core'
 import type { AgentArchetype, CustomAgentKind } from '~/types/domain'
-import type { AppSlots } from './slots'
 
 /**
- * Custom agent kinds as remote capability manifests (slice 2 of the modular-vue
- * adoption — docs/initiatives/modular-vue-adoption.md).
+ * Custom agent-kind projection (slice 2 of the modular-vue adoption —
+ * docs/initiatives/modular-vue-adoption.md).
  *
- * A deployment's BACKEND-registered agent kinds arrive in the workspace snapshot
- * as `customAgentKinds` (wire data). Rather than mutating a module-global
- * catalog, they're modeled as a single {@link RemoteModuleManifest} whose
- * `agentKinds` slot carries the data. cat-factory holds ONE active manifest per
- * workspace (swapped on snapshot), so the agents store reads its `.slots`
- * directly — the sanctioned single-active-manifest shape (the merge-many
- * `mergeRemoteManifests` helper is for holding several manifests at once, which
- * we don't). CODE-shipped consumer kinds instead enter via the static
- * `agentKinds` slot (a `registerAppModule` module); the store merges both.
+ * A deployment's BACKEND-registered agent kinds arrive in the workspace snapshot as
+ * `customAgentKinds` (wire data), folded into the shared per-workspace capability manifest
+ * (see `./capabilities.ts`, generalized to carry custom TASK types too). CODE-shipped consumer
+ * kinds instead enter via the static `agentKinds` slot (a `registerAppModule` module); the agents
+ * store merges both. This module holds only the wire→display projection they share.
  */
 
-/** The stable id for the per-workspace capability manifest built from the snapshot. */
-export const WORKSPACE_CAPABILITIES_MANIFEST_ID = 'cat-factory:workspace-capabilities'
-
-/**
- * A deterministic, key-order-independent content signature of the custom kinds, used as the
- * manifest `version`. The workspace snapshot re-delivers the SAME deployment-registered kinds on
- * every board-event refresh (a full `workspace.refresh()` runs `hydrateCustomKinds` each time), so
- * a content-derived version lets the store skip re-projecting an UNCHANGED catalog — otherwise
- * every refresh would replace the `customAgentKindMeta` read-model and needlessly invalidate the
- * ~17 `agentKindMeta` / `isKnownAgentKind` consumers. It still changes (and swaps wholesale) when a
- * different workspace's kinds actually differ. Serialized as fixed-order tuples of only the fields
- * that affect display/pairing, so a re-serialization with reordered object keys can't spuriously
- * differ.
- */
-export function capabilitiesManifestVersion(kinds: readonly CustomAgentKind[]): string {
-  return JSON.stringify(
-    kinds.map((k) => [
-      k.kind,
-      k.container,
-      k.presentation.label,
-      k.presentation.icon,
-      k.presentation.color,
-      k.presentation.description,
-      k.presentation.category ?? null,
-      k.presentation.resultView ?? null,
-    ]),
-  )
-}
-
-/**
- * Model the snapshot's `customAgentKinds` as a single remote capability manifest. The `version` is
- * a {@link capabilitiesManifestVersion content signature} so identical snapshots produce an
- * identical manifest — which `useAgentsStore().hydrateCustomKinds` uses to no-op an unchanged
- * re-hydrate. Swapped wholesale (not diffed) when the content genuinely changes.
- */
-export function buildAgentCapabilitiesManifest(
-  kinds: readonly CustomAgentKind[],
-): RemoteModuleManifest<AppSlots> {
-  return {
-    id: WORKSPACE_CAPABILITIES_MANIFEST_ID,
-    version: capabilitiesManifestVersion(kinds),
-    slots: { agentKinds: [...kinds] },
-  }
-}
-
 /**
  * Project a wire `CustomAgentKind` onto the frontend's display `AgentArchetype`
  * (icon/label/color/description + optional category/resultView). The inverse of

package/app/modular/capabilities.spec.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest'
+import {
+  buildWorkspaceCapabilitiesManifest,
+  WORKSPACE_CAPABILITIES_MANIFEST_ID,
+  workspaceCapabilitiesVersion,
+} from './capabilities'
+import type { AgentKind, CustomAgentKind, CustomTaskType } from '~/types/domain'
+
+const kind = (
+  over: Partial<CustomAgentKind['presentation']> = {},
+  kindId = 'acme-audit',
+): CustomAgentKind => ({
+  kind: kindId as AgentKind,
+  container: true,
+  presentation: {
+    label: 'Audit',
+    icon: 'i-lucide-shield',
+    color: '#fff',
+    description: 'd',
+    ...over,
+  },
+})
+
+const taskType = (
+  over: Partial<CustomTaskType['presentation']> = {},
+  id = 'acme:incident',
+): CustomTaskType => ({
+  taskType: id,
+  presentation: {
+    label: 'Incident',
+    icon: 'i-lucide-siren',
+    color: '#ef4444',
+    description: 'd',
+    ...over,
+  },
+})
+
+describe('buildWorkspaceCapabilitiesManifest', () => {
+  it('models the snapshot capabilities as one manifest carrying BOTH slots', () => {
+    const kinds = [kind()]
+    const taskTypes = [taskType()]
+    const manifest = buildWorkspaceCapabilitiesManifest(kinds, taskTypes)
+    expect(manifest.id).toBe(WORKSPACE_CAPABILITIES_MANIFEST_ID)
+    expect(manifest.slots?.agentKinds).toEqual(kinds)
+    expect(manifest.slots?.taskTypes).toEqual(taskTypes)
+  })
+
+  it('copies the inputs (no aliasing of the caller arrays)', () => {
+    const kinds = [kind()]
+    const taskTypes = [taskType()]
+    const manifest = buildWorkspaceCapabilitiesManifest(kinds, taskTypes)
+    kinds.push(kind())
+    taskTypes.push(taskType())
+    expect(manifest.slots?.agentKinds).toHaveLength(1)
+    expect(manifest.slots?.taskTypes).toHaveLength(1)
+  })
+
+  it('derives an identical version for identical content (so an unchanged re-hydrate no-ops)', () => {
+    expect(buildWorkspaceCapabilitiesManifest([kind()], [taskType()]).version).toBe(
+      buildWorkspaceCapabilitiesManifest([kind()], [taskType()]).version,
+    )
+  })
+
+  it('changes the version when an agent-kind display/pairing field or the kind set differs', () => {
+    const base = workspaceCapabilitiesVersion([kind()], [])
+    expect(workspaceCapabilitiesVersion([kind({ label: 'Renamed' })], [])).not.toBe(base)
+    expect(workspaceCapabilitiesVersion([kind({ resultView: 'acme:audit' })], [])).not.toBe(base)
+    expect(workspaceCapabilitiesVersion([kind({}, 'acme-other')], [])).not.toBe(base)
+    expect(workspaceCapabilitiesVersion([kind(), kind({}, 'acme-two')], [])).not.toBe(base)
+    expect(workspaceCapabilitiesVersion([], [])).not.toBe(base)
+  })
+
+  it('changes the version when a task-type field, its fields, or the set differs', () => {
+    const base = workspaceCapabilitiesVersion([], [taskType()])
+    expect(workspaceCapabilitiesVersion([], [taskType({ label: 'Renamed' })])).not.toBe(base)
+    expect(workspaceCapabilitiesVersion([], [taskType({}, 'acme:other')])).not.toBe(base)
+    expect(
+      workspaceCapabilitiesVersion([], [{ ...taskType(), defaultPipelineId: 'pl_review' }]),
+    ).not.toBe(base)
+    expect(
+      workspaceCapabilitiesVersion(
+        [],
+        [{ ...taskType(), fields: [{ key: 'sev', label: 'Severity', type: 'text' }] }],
+      ),
+    ).not.toBe(base)
+    expect(workspaceCapabilitiesVersion([], [])).not.toBe(base)
+  })
+})