@cat-factory/app 0.254.2 → 0.255.0

package/README.md

@@ -271,12 +271,20 @@ The builder's palette narrows on two axes, and both controls sit on one row abov
 (`PipelinePurposeSelect` above `AgentTierSelect`), each with its own "n hidden" hint so neither
 narrowing reads as an empty catalog. The tier says how deep to look; the **purpose** says what
 the pipeline is for (`build` / `document` / `review` / `research` / `planning`), and the palette
-drops the categories that purpose has no use for. The purpose is not a view preference: it is
+drops the categories that purpose has no use for. It reaches past the palette: the saved-pipeline
+library in the builder's third column lists the pipelines built for the purpose being edited, so
+one dial narrows both ends of the slideover. The purpose is not a view preference either: it is
 saved on the pipeline and also decides which task pickers offer it, which is why the control
 writes through to the draft while the tier writes to its own store.
 
-Purpose is filtered by two predicates in `@cat-factory/contracts`, and the difference between
-them is the point:
+`Pipeline.purpose` is MANDATORY, so there is no unclassified state for any of these surfaces to
+invent a policy for: a new draft starts at `build` (what an unclassified pipeline always behaved
+as) and the dial only moves it. What each surface still has to read carefully is a purpose the
+BUNDLE cannot name, which the persisted, closed vocabulary makes reachable in both directions (a
+browser older than a new member, a row older than a retired one).
+
+Purpose is filtered by three predicates in `@cat-factory/contracts`, and the difference between
+the first two is the point:
 
 - `purposeSuggestsAgentCategory` is **relevance**: what the palette OFFERS. Opinionated (a
   review pipeline designs nothing; a planning pipeline has no pull request to gate), because a
@@ -284,14 +292,28 @@ them is the point:
 - `purposeAllowsAgentCategory` is **compatibility**: what the builder will SAVE. It states only
   what is contradictory (a pipeline that writes no code carrying an implementation step) and
   drives the draft's conflict warning.
+- `pipelineMatchesPurpose` is **membership**: which SAVED pipelines the builder's library lists,
+  reduced with the label and archive dials in `utils/pipelineLibrary.ts`. The one dial in that
+  column whose control is elsewhere, so it is the one that owes a "n hidden" hint. It may be
+  exact where the pickers' `pipelineAllowedForTaskType` is permissive, because it narrows a list
+  somebody is BROWSING rather than one they are about to run from: two known purposes never mix,
+  while a pipeline whose classifier this build cannot NAME is listed at every purpose rather than
+  vanishing from the editor that has to fix it.
+
+The library's purpose is a BROWSING dial of its own, defaulting to the draft's and relaxed by the
+hint itself ("show every purpose"). Reading the draft directly is the trap: it is an authoring
+field with no "off" setting, so a hint that only NAMES the absence would send the reader to a
+control whose every setting narrows and whose every change is saved. A dial that hides rows owes
+both a count and a way back, and the way back may not be an edit.
 
 Relevance is a subset of compatibility, asserted over the whole grid in `pipeline.spec.ts`. Keep
 it that way: the palette may hide what the save gate tolerates, so tightening the relevance table
 never turns a stored pipeline into one its own editor refuses, but offering a kind the save gate
 then rejects would be a dead end with the refusal arriving after the work.
 
-**Each hint counts what relaxing THAT dial alone would reveal**, which is why the reduction is one
-function (`utils/agentPalette.ts`) rather than two chained filters at the call site. Chaining them
+**Each hint counts what relaxing THAT dial alone would reveal**, which is why each reduction is one
+function (`utils/agentPalette.ts` for the catalog, `utils/pipelineLibrary.ts` for the library)
+rather than chained filters at the call site. Chaining them
 and subtracting the lengths gives the second dial an honest count and hands the first one the whole
 rest of the catalog: at the default `basic` tier a `planning` pipeline claimed thirteen kinds hidden
 for its purpose when switching back to Build revealed three, the other ten being tier-hidden either

package/app/components/palettes/AgentPalette.vue

@@ -17,8 +17,9 @@ defineEmits<{
 }>()
 // The purpose of the pipeline being built, edited right here by the control above the catalog.
 // It narrows the palette to the categories that purpose has any use for (a review pipeline
-// designs nothing and builds nothing, see `purposeSuggestsAgentCategory`); `null` shows all.
-const props = defineProps<{ purpose?: PipelinePurpose | null }>()
+// designs nothing and builds nothing, see `purposeSuggestsAgentCategory`). Required, like the
+// field it edits: a draft is classified from the moment it exists.
+const props = defineProps<{ purpose: PipelinePurpose }>()
 
 // The post-release-health gate is only meaningful — and only accepted by the backend —
 // with an observability integration connected, so it appears in the palette ONLY then.

package/app/components/palettes/PipelinePurposeSelect.vue

@@ -13,8 +13,8 @@ import { isPipelinePurpose, PIPELINE_PURPOSES, type PipelinePurpose } from '@cat
 const { t } = useI18n()
 
 const props = defineProps<{
-  /** The draft's purpose. `null` = unclassified, which narrows nothing. */
-  purpose?: PipelinePurpose | null
+  /** The draft's purpose. Required: every pipeline carries one, the builder's default being `build`. */
+  purpose: PipelinePurpose
   /** How many agent kinds the current purpose hides. Renders the "n hidden" hint when > 0. */
   hiddenCount?: number
 }>()
@@ -31,19 +31,15 @@ const PURPOSE_LABELS = computed<Record<PipelinePurpose, string>>(() => ({
   planning: t('pipeline.builder.purposeOption.planning'),
 }))
 
-// The button text: the chosen purpose, or the placeholder while the draft carries none. An
-// unclassified draft reads as an unmade choice rather than as a purpose called "none", because
-// that is what it is: nothing is filtered until one is picked.
-//
-// A stored purpose this build has no label for is NAMED as unrecognised and quoted back, not
-// folded into the placeholder and not left to render as an empty string after the colon. It is
-// the one state the user cannot diagnose from the control: the palette is unfiltered (see
-// `purposeSuggestsAgentCategory`), so a blank label would read as a pipeline nobody classified
-// while the saved row says otherwise. The menu still lists every current member, so naming the
-// value is also the way out of it.
+// The button text. A stored purpose this build has no label for is NAMED as unrecognised and
+// quoted back, rather than left to render as an empty string after the colon: it is the one state
+// the user cannot diagnose from the control, because a purpose this bundle cannot name narrows
+// nothing (see `purposeSuggestsAgentCategory`), so a blank label would read as a pipeline nobody
+// classified while the saved row says otherwise. The menu still lists every member this build has,
+// so naming the value is also the way out of it. Reachable even though the field is mandatory: the
+// value is persisted and this bundle can be older than the member it reads.
 const current = computed(() => {
   const purpose = props.purpose
-  if (!purpose) return t('pipeline.builder.purposePlaceholder')
   if (!isPipelinePurpose(purpose)) return t('pipeline.builder.purposeUnrecognized', { purpose })
   return PURPOSE_LABELS.value[purpose]
 })

package/app/components/pipeline/PipelineBuilder.vue

@@ -11,6 +11,7 @@ import OutputBudgetInput from '~/components/pipeline/OutputBudgetInput.vue'
 import BinaryOutputStepPicker from '~/components/pipeline/BinaryOutputStepPicker.vue'
 import { ESTIMATE_AXES, ESTIMATE_AXIS_FIELD, type EstimateAxis } from '~/utils/estimateGating'
 import { showOverrideField } from '~/utils/uiMode'
+import { narrowPipelineLibrary } from '~/utils/pipelineLibrary'
 import {
   agentKindMeta,
   companionForProducer,
@@ -403,14 +404,26 @@ const showArchived = ref(false)
 const allLabels = computed(() =>
   [...new Set(pipelines.pipelines.flatMap((p) => p.labels ?? []))].sort(),
 )
-const archivedCount = computed(() => pipelines.pipelines.filter((p) => p.archived).length)
-const visiblePipelines = computed(() =>
-  pipelines.pipelines.filter((p) => {
-    if (!showArchived.value && p.archived) return false
-    if (labelFilter.value && !(p.labels ?? []).includes(labelFilter.value)) return false
-    return true
+// The library is narrowed by the same purpose the palette is: browsing at `review` lists the
+// pipelines built for reviewing, not the whole workspace catalog. `narrowPipelineLibrary` owns the
+// reduction so the rule is unit-testable and each hint counts the population its own control can
+// actually reveal, rather than the rows another dial is hiding either way.
+//
+// It is a BROWSING dial of its own, not a read of `draftPurpose`. The draft's purpose is an
+// authoring field with no "unclassified" setting, so keying the library straight off it would
+// leave the only ways back through the hidden rows a re-classification of the pipeline being
+// edited (which persists) or discarding the draft. This ref is what "relax THIS dial alone" means
+// for the purpose: it defaults to following the draft and the hint below toggles it, changing what
+// is listed and nothing that gets saved.
+const browseEveryPurpose = ref(false)
+const library = computed(() =>
+  narrowPipelineLibrary(pipelines.pipelines, {
+    purpose: browseEveryPurpose.value ? null : pipelines.draftPurpose,
+    label: labelFilter.value,
+    showArchived: showArchived.value,
   }),
 )
+const visiblePipelines = computed(() => library.value.offered)
 async function toggleArchive(p: Pipeline) {
   try {
     if (p.archived) await pipelines.unarchive(p.id)
@@ -1131,7 +1144,7 @@ async function clone(p: Pipeline) {
               {{ t('pipeline.builder.savedPipelines') }}
             </h3>
             <UButton
-              v-if="archivedCount"
+              v-if="library.archivedInScope"
               :icon="showArchived ? 'i-lucide-archive-restore' : 'i-lucide-archive'"
               :color="showArchived ? 'primary' : 'neutral'"
               variant="ghost"
@@ -1145,7 +1158,7 @@ async function clone(p: Pipeline) {
               {{
                 showArchived
                   ? t('pipeline.builder.hideArchived')
-                  : t('pipeline.builder.archivedCount', { count: archivedCount })
+                  : t('pipeline.builder.archivedCount', { count: library.archivedInScope })
               }}
             </UButton>
           </div>
@@ -1174,6 +1187,40 @@ async function clone(p: Pipeline) {
             </UBadge>
           </div>
 
+          <!-- What the purpose is holding back, and the way past it. Stated here rather than
+               beside the palette's purpose control because this is where the absence is noticed:
+               a narrowed library must never read as the whole one, and a hint that only NAMES an
+               absence sends the reader to the authoring dial one column left, whose every setting
+               narrows and whose every change is saved. -->
+          <div
+            v-if="browseEveryPurpose || library.hiddenByPurpose"
+            class="mb-2 flex shrink-0 flex-wrap items-center gap-x-2 px-1 text-[10px] text-slate-500"
+          >
+            <span>
+              {{
+                browseEveryPurpose
+                  ? t('pipeline.builder.everyPurposeListed')
+                  : t(
+                      'pipeline.builder.purposeHiddenPipelines',
+                      { count: library.hiddenByPurpose },
+                      library.hiddenByPurpose,
+                    )
+              }}
+            </span>
+            <button
+              type="button"
+              class="underline underline-offset-2 hover:text-slate-300"
+              data-testid="pipeline-library-purpose-toggle"
+              @click="browseEveryPurpose = !browseEveryPurpose"
+            >
+              {{
+                browseEveryPurpose
+                  ? t('pipeline.builder.narrowToDraftPurpose')
+                  : t('pipeline.builder.listEveryPurpose')
+              }}
+            </button>
+          </div>
+
           <ul class="flex-1 space-y-1.5 pe-1 lg:min-h-0 lg:overflow-y-auto">
             <li
               v-for="p in visiblePipelines"

package/app/composables/usePipelineHealth.spec.ts

@@ -20,6 +20,7 @@ function builtin(agentKinds: string[], over: Partial<Pipeline> = {}): Pipeline {
   return {
     id: `pl_test_${nextId++}`,
     name: 'Test',
+    purpose: 'build',
     agentKinds,
     builtin: true,
     version: 1,

package/app/stores/pipelines/context.ts

@@ -96,7 +96,7 @@ export interface PipelinesContext {
   draftTesterQuality: Ref<(TesterQualityConfig | null)[]>
   draftStepOptions: Ref<(StepOptions | null)[]>
   draftLabels: Ref<string[]>
-  draftPurpose: Ref<PipelinePurpose | null>
+  draftPurpose: Ref<PipelinePurpose>
   draftName: Ref<string>
   draftDescription: Ref<string>
   editingId: Ref<string | null>

package/app/stores/pipelines/draftActions.ts

@@ -165,7 +165,7 @@ export function createPipelineDraftActions(ctx: PipelinesContext) {
     draftTesterQuality.value = []
     draftStepOptions.value = []
     draftLabels.value = []
-    draftPurpose.value = null
+    draftPurpose.value = 'build'
     draftName.value = 'New pipeline'
     draftDescription.value = ''
     editingId.value = null
@@ -185,7 +185,7 @@ export function createPipelineDraftActions(ctx: PipelinesContext) {
     )
     draftStepOptions.value = pipeline.agentKinds.map((_, i) => pipeline.stepOptions?.[i] ?? null)
     draftLabels.value = [...(pipeline.labels ?? [])]
-    draftPurpose.value = pipeline.purpose ?? null
+    draftPurpose.value = pipeline.purpose
     draftName.value = pipeline.name
     draftDescription.value = pipeline.description ?? ''
     editingId.value = pipeline.id

package/app/stores/pipelines/persistence.ts

@@ -62,10 +62,10 @@ export function createPipelinePersistence(
       stepOptions: ctx.draftStepOptions.value.map((o) => o ?? null),
       // Only send labels when there are any.
       ...(ctx.draftLabels.value.length ? { labels: [...ctx.draftLabels.value] } : {}),
-      // Only send purpose when the pipeline is classified (null ⇒ leave unclassified). Like the
-      // legacy per-step arrays, an omitted `purpose` on update reads as "keep existing"; clearing
-      // a classification back to unclassified is not a supported edit (every built-in ships one).
-      ...(ctx.draftPurpose.value ? { purpose: ctx.draftPurpose.value } : {}),
+      // ALWAYS sent, like `stepOptions` above and for the same reason: `purpose` is mandatory on
+      // create, and on update an omitted field reads as "keep existing", so a re-classification
+      // would silently not persist. There is no "unclassified" to clear back to.
+      purpose: ctx.draftPurpose.value,
     }
   }
 

package/app/stores/pipelines.ts

@@ -70,11 +70,15 @@ export const usePipelinesStore = defineStore('pipelines', () => {
   const draftLabels = ref<string[]>([])
   /**
    * The use-case classifier of the pipeline being assembled/edited (`build` / `document` /
-   * `review` / `research` / `planning`), or null when unclassified. Drives which task pickers
-   * offer the saved pipeline and which agent kinds the builder palette shows (a non-`build`
-   * purpose hides the Implementation/Testing kinds).
+   * `review` / `research` / `planning`). Drives which task pickers offer the saved pipeline, which
+   * agent kinds the builder palette shows (a non-`build` purpose hides the Implementation/Testing
+   * kinds) and which saved pipelines the library lists.
+   *
+   * Never null: `Pipeline.purpose` is mandatory, so a draft is classified from the moment it
+   * exists. `build` is the default because it is what an unclassified pipeline has always behaved
+   * as, so the dial starts where the old absence pointed rather than at a choice nobody made.
    */
-  const draftPurpose = ref<PipelinePurpose | null>(null)
+  const draftPurpose = ref<PipelinePurpose>('build')
   const draftName = ref('New pipeline')
   /** Prose description for the pipeline being assembled/edited (shown in the pickers). */
   const draftDescription = ref('')

package/app/utils/agentPalette.spec.ts

@@ -31,27 +31,33 @@ const CATALOG: AgentArchetype[] = [
 ]
 
 describe('narrowAgentPalette', () => {
-  it('narrows nothing for an unclassified pipeline at the widest tier', () => {
-    const { offered, hiddenByPurpose, hiddenByTier } = narrowAgentPalette(CATALOG, null, 'advanced')
+  it('narrows nothing for a build pipeline at the widest tier', () => {
+    const { offered, hiddenByPurpose, hiddenByTier } = narrowAgentPalette(
+      CATALOG,
+      'build',
+      'advanced',
+    )
     expect(offered.map((a) => a.kind)).toEqual(CATALOG.map((a) => a.kind))
     expect(hiddenByPurpose).toBe(0)
     expect(hiddenByTier).toBe(0)
   })
 
   it('accumulates the tiers when the purpose narrows nothing', () => {
-    expect(narrowAgentPalette(CATALOG, null, 'basic').offered.map((a) => a.kind)).toEqual([
+    expect(narrowAgentPalette(CATALOG, 'build', 'basic').offered.map((a) => a.kind)).toEqual([
       'coder',
       'architect',
       'documenter',
     ])
-    expect(narrowAgentPalette(CATALOG, null, 'intermediate').offered.map((a) => a.kind)).toEqual([
-      'coder',
-      'architect',
-      'documenter',
-      // An undeclared tier defaults to intermediate, so it appears here.
-      'acme-auditor',
-    ])
-    expect(narrowAgentPalette(CATALOG, null, 'basic').hiddenByTier).toBe(3)
+    expect(narrowAgentPalette(CATALOG, 'build', 'intermediate').offered.map((a) => a.kind)).toEqual(
+      [
+        'coder',
+        'architect',
+        'documenter',
+        // An undeclared tier defaults to intermediate, so it appears here.
+        'acme-auditor',
+      ],
+    )
+    expect(narrowAgentPalette(CATALOG, 'build', 'basic').hiddenByTier).toBe(3)
   })
 
   it('counts each dial against what the OTHER already admits', () => {

package/app/utils/agentPalette.ts

@@ -42,7 +42,7 @@ export interface NarrowedAgentPalette<T> {
  */
 export function narrowAgentPalette<T extends Pick<AgentArchetype, 'tier' | 'category'>>(
   archetypes: readonly T[],
-  purpose: PipelinePurpose | null | undefined,
+  purpose: PipelinePurpose,
   tier: AgentTier,
 ): NarrowedAgentPalette<T> {
   const relevant = (a: T) => !a.category || purposeSuggestsAgentCategory(purpose, a.category)

package/app/utils/pipeline.spec.ts

@@ -74,16 +74,19 @@ describe('pipelineAllowedForTaskType', () => {
     expect(pipelineAllowedForTaskType(pipeline({ purpose: 'document' }), 'document')).toBe(true)
     expect(pipelineAllowedForTaskType(pipeline({ purpose: 'build' }), 'document')).toBe(false)
     expect(pipelineAllowedForTaskType(pipeline({ purpose: 'research' }), 'document')).toBe(false)
-    // An unclassified pipeline is hidden from a document task (it requires the explicit classifier).
-    expect(pipelineAllowedForTaskType(pipeline({ purpose: undefined }), 'document')).toBe(false)
+    // A classifier this build cannot NAME is hidden too: this narrowing requires the explicit
+    // member, because a non-document pipeline on a document task authors no document at all.
+    expect(pipelineAllowedForTaskType(pipeline({ purpose: UNKNOWN_PURPOSE }), 'document')).toBe(
+      false,
+    )
   })
 
   it('a review task offers ONLY review-purpose pipelines', () => {
     expect(pipelineAllowedForTaskType(pipeline({ purpose: 'review' }), 'review')).toBe(true)
     expect(pipelineAllowedForTaskType(pipeline({ purpose: 'build' }), 'review')).toBe(false)
     expect(pipelineAllowedForTaskType(pipeline({ purpose: 'document' }), 'review')).toBe(false)
-    // An unclassified pipeline is hidden from a review task (it requires the explicit classifier).
-    expect(pipelineAllowedForTaskType(pipeline({ purpose: undefined }), 'review')).toBe(false)
+    // Same disposition as the document task's, for the same reason.
+    expect(pipelineAllowedForTaskType(pipeline({ purpose: UNKNOWN_PURPOSE }), 'review')).toBe(false)
   })
 
   it('a programmatic task (feature / bug) hides only what cannot ship code', () => {
@@ -99,26 +102,27 @@ describe('pipelineAllowedForTaskType', () => {
     }
   })
 
-  it('keeps an UNCLASSIFIED pipeline on a feature / bug task', () => {
-    // The one place this narrowing runs opposite to the document/review one, and it has to: a
-    // `purpose` is optional at every write boundary (the builder leaves it unset by default, a
-    // registered deployment pipeline need not declare one), so requiring it here would hide a
-    // workspace's own hand-built pipelines from the picker they were built for — silently, with
-    // nothing on screen to explain the absence. Unclassified is not known-wrong for a feature the
-    // way a document preset is.
+  it('keeps a pipeline whose classifier this build cannot name on a feature / bug task', () => {
+    // The one place this narrowing runs opposite to the document/review one, and it has to. The
+    // value is persisted, so a deployment's own classifier (or one retired since the row was
+    // written) reaches a bundle with no member for it — and hiding it would take that pipeline out
+    // of the picker people use most, silently, with nothing on screen to explain the absence. It is
+    // not known-wrong for a feature the way a document preset is.
     for (const type of ['feature', 'bug'] as const) {
-      expect(pipelineAllowedForTaskType(pipeline({ purpose: undefined }), type)).toBe(true)
+      expect(pipelineAllowedForTaskType(pipeline({ purpose: UNKNOWN_PURPOSE }), type)).toBe(true)
     }
-    // Still hidden from the types whose narrowing DOES demand the explicit classifier.
-    expect(pipelineAllowedForTaskType(pipeline({ purpose: undefined }), 'document')).toBe(false)
-    expect(pipelineAllowedForTaskType(pipeline({ purpose: undefined }), 'review')).toBe(false)
+    // Still hidden from the types whose narrowing DOES demand the explicit member.
+    expect(pipelineAllowedForTaskType(pipeline({ purpose: UNKNOWN_PURPOSE }), 'document')).toBe(
+      false,
+    )
+    expect(pipelineAllowedForTaskType(pipeline({ purpose: UNKNOWN_PURPOSE }), 'review')).toBe(false)
   })
 
   it('an un-narrowed task type stays unrestricted (spike, ralph, custom, undefined)', () => {
     // A custom (namespaced) deployment type has no purpose mapping we could infer, and `spike` /
     // `ralph` pin their own default pipeline instead of narrowing the picker.
     for (const type of ['spike', 'ralph', 'acme:incident', undefined] as const) {
-      for (const purpose of ['build', 'document', 'review', 'research', undefined] as const) {
+      for (const purpose of ['build', 'document', 'review', 'research'] as const) {
         expect(pipelineAllowedForTaskType(pipeline({ purpose }), type)).toBe(true)
       }
     }
@@ -151,8 +155,8 @@ describe('pipelineAllowedForBlockLevel (initiative binding)', () => {
 })
 
 describe('purposeAllowsAgentCategory (builder save gate)', () => {
-  it('a build (or unclassified) pipeline may use every category', () => {
-    for (const purpose of ['build', null, undefined] as const) {
+  it('a build pipeline, and one whose classifier this build cannot name, may use every category', () => {
+    for (const purpose of ['build', UNKNOWN_PURPOSE] as const) {
       for (const cat of AGENT_CATEGORIES) {
         expect(purposeAllowsAgentCategory(purpose, cat)).toBe(true)
       }
@@ -173,8 +177,8 @@ describe('purposeAllowsAgentCategory (builder save gate)', () => {
 })
 
 describe('purposeSuggestsAgentCategory (builder palette filter)', () => {
-  it('offers the whole catalog to a build pipeline and to an unclassified one', () => {
-    for (const purpose of ['build', null, undefined] as const) {
+  it('offers the whole catalog to a build pipeline, and to one it cannot name', () => {
+    for (const purpose of ['build', UNKNOWN_PURPOSE] as const) {
       for (const cat of AGENT_CATEGORIES) {
         expect(purposeSuggestsAgentCategory(purpose, cat)).toBe(true)
       }

package/app/utils/pipelineLibrary.spec.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from 'vitest'
+import { PIPELINE_PURPOSES } from '@cat-factory/contracts'
+import type { Pipeline } from '~/types/domain'
+import { narrowPipelineLibrary } from '~/utils/pipelineLibrary'
+
+type Row = Pick<Pipeline, 'purpose' | 'labels' | 'archived'> & { id: string }
+
+const row = (id: string, purpose: Pipeline['purpose'], extra: Partial<Row> = {}): Row => ({
+  id,
+  purpose,
+  ...extra,
+})
+
+// A purpose this build has no member for: what a row saved by a newer build (or before a member
+// was retired) looks like on the way back out of the store. Reachable even though the field is
+// mandatory, which is the whole reason the predicates still narrow the value they are handed.
+const UNKNOWN_PURPOSE = 'acme-migration' as Pipeline['purpose']
+
+// Spread across all three dials, so neither count can come out right by coincidence: an archived
+// row and a differently-labelled row are excluded by the OTHER dials either way.
+const LIBRARY: Row[] = [
+  row('build-a', 'build'),
+  row('build-archived', 'build', { archived: true }),
+  row('review-a', 'review'),
+  row('review-tagged', 'review', { labels: ['nightly'] }),
+  row('review-archived-tagged', 'review', { archived: true, labels: ['nightly'] }),
+  row('document-tagged', 'document', { labels: ['nightly'] }),
+]
+
+describe('narrowPipelineLibrary', () => {
+  it('lists every purpose when the library is browsed at none', () => {
+    // `null` is the library's own relaxation, not an unclassified draft: `Pipeline.purpose` is
+    // mandatory, so the reader asking to browse past the purpose is the only way to get here.
+    const { offered, hiddenByPurpose } = narrowPipelineLibrary(LIBRARY, {
+      purpose: null,
+      showArchived: true,
+    })
+    expect(offered.map((p) => p.id)).toEqual(LIBRARY.map((p) => p.id))
+    expect(hiddenByPurpose).toBe(0)
+  })
+
+  it('lists the pipelines built for the purpose being browsed at', () => {
+    const { offered, hiddenByPurpose } = narrowPipelineLibrary(LIBRARY, { purpose: 'review' })
+    expect(offered.map((p) => p.id)).toEqual(['review-a', 'review-tagged'])
+    // `build-archived` is hidden by the archive toggle either way, so the purpose does not claim it.
+    expect(hiddenByPurpose).toBe(2)
+  })
+
+  it('measures the purpose count against what the other dials already admit', () => {
+    // The rule `narrowAgentPalette` established: each hint promises "relax THIS dial alone and you
+    // get n more". Counting over the whole library would name `build-a` here, which the label
+    // filter hides at every purpose.
+    const { offered, hiddenByPurpose } = narrowPipelineLibrary(LIBRARY, {
+      purpose: 'review',
+      label: 'nightly',
+    })
+    expect(offered.map((p) => p.id)).toEqual(['review-tagged'])
+    expect(hiddenByPurpose).toBe(1)
+  })
+
+  it('counts the archived rows the OTHER dials admit, not the whole catalog', () => {
+    // The count the "Archived (n)" toggle renders. Against the raw catalog it would promise rows
+    // the toggle cannot reveal: two pipelines are archived, but only one of them is a `review` one.
+    expect(narrowPipelineLibrary(LIBRARY, { purpose: 'review' }).archivedInScope).toBe(1)
+    expect(narrowPipelineLibrary(LIBRARY, { purpose: 'planning' }).archivedInScope).toBe(0)
+    expect(narrowPipelineLibrary(LIBRARY, { purpose: null }).archivedInScope).toBe(2)
+    expect(
+      narrowPipelineLibrary(LIBRARY, { purpose: null, label: 'nightly' }).archivedInScope,
+    ).toBe(1)
+  })
+
+  it('keeps the archived count steady across the toggle it governs', () => {
+    // Unlike `hiddenByPurpose`, this one may NOT drop to zero once the dial is relaxed: it decides
+    // whether the toggle is offered at all, so a count that vanished when the toggle worked would
+    // strand the archived rows visible with no way to hide them again.
+    const shown = narrowPipelineLibrary(LIBRARY, { purpose: 'review', showArchived: true })
+    expect(shown.offered.map((p) => p.id)).toEqual([
+      'review-a',
+      'review-tagged',
+      'review-archived-tagged',
+    ])
+    expect(shown.archivedInScope).toBe(1)
+  })
+
+  it('narrows by neither purpose this build cannot name', () => {
+    // Same disposition as the palette's: an unrecognised value is one this build has nothing to
+    // narrow BY and nothing to narrow it AGAINST, never a reason to guess a current member. A
+    // stored row carrying one stays reachable in the editor that has to fix it.
+    const stored = [...LIBRARY, row('acme', UNKNOWN_PURPOSE)]
+    for (const purpose of PIPELINE_PURPOSES) {
+      expect(narrowPipelineLibrary(stored, { purpose }).offered.some((p) => p.id === 'acme')).toBe(
+        true,
+      )
+    }
+    expect(narrowPipelineLibrary(stored, { purpose: UNKNOWN_PURPOSE })).toEqual({
+      offered: stored.filter((p) => !p.archived),
+      hiddenByPurpose: 0,
+      archivedInScope: 2,
+    })
+  })
+})

package/app/utils/pipelineLibrary.ts

@@ -0,0 +1,69 @@
+import { pipelineMatchesPurpose, type PipelinePurpose } from '@cat-factory/contracts'
+import type { Pipeline } from '~/types/domain'
+
+/** What the pipeline builder's saved-pipeline library is being browsed at. */
+export interface PipelineLibraryFilters {
+  /**
+   * The purpose to list, or `null` for "every purpose" — the library's own relaxation, NOT an
+   * unclassified draft. `Pipeline.purpose` is mandatory, so the draft always has one; `null` is
+   * the reader saying they want to browse past it.
+   */
+  purpose?: PipelinePurpose | null
+  /** The picked organizational label, or `null` for all of them. */
+  label?: string | null
+  /** Whether archived pipelines are included. */
+  showArchived?: boolean
+}
+
+/**
+ * The saved-pipeline library narrowed to what it lists, plus what each hidden-by-default dial is
+ * holding back.
+ *
+ * Both counts are measured against what the OTHER dials already admit, which is the promise
+ * `narrowAgentPalette` established: relax THIS dial alone and you get n more. Counting either over
+ * the whole catalog would name rows another filter is hiding either way, sending the reader to a
+ * control that cannot produce them.
+ *
+ * The label chips are the one dial with no count, because they are the one dial that already shows
+ * its own selection and its own alternatives.
+ */
+export interface NarrowedPipelineLibrary<T> {
+  /** The pipelines every dial admits: what the library renders, in input order. */
+  offered: T[]
+  /** How many more the CURRENT label + archive selection would list at every purpose. */
+  hiddenByPurpose: number
+  /**
+   * How many ARCHIVED pipelines the current purpose + label selection covers.
+   *
+   * Deliberately independent of `showArchived`, unlike {@link hiddenByPurpose}: this is what the
+   * archive toggle governs, and it has to be the same number in both of the toggle's positions or
+   * the control that turned archived rows ON would vanish the moment it worked, stranding them
+   * visible with no way back. While they are hidden it is also exactly what relaxing that dial
+   * alone would add.
+   */
+  archivedInScope: number
+}
+
+/**
+ * Reduce `pipelines` to the rows the builder's library lists under `filters`.
+ *
+ * A pure reduction rather than three predicates inlined in the template for the reason
+ * {@link import('./agentPalette').narrowAgentPalette} is one: it decides what is VISIBLE and it
+ * owes an honest count of what it hid, and a count re-derived at the call site as a subtraction
+ * measures the wrong population. The purpose rule itself lives in `@cat-factory/contracts` beside
+ * the palette's and the pickers', so the three cannot read a stored `purpose` in different
+ * directions.
+ */
+export function narrowPipelineLibrary<T extends Pick<Pipeline, 'purpose' | 'labels' | 'archived'>>(
+  pipelines: readonly T[],
+  filters: PipelineLibraryFilters,
+): NarrowedPipelineLibrary<T> {
+  const labelled = (p: T) => !filters.label || (p.labels ?? []).includes(filters.label)
+  const listed = (p: T) => Boolean(filters.showArchived) || !p.archived
+  const suits = (p: T) => pipelineMatchesPurpose(p, filters.purpose)
+  return {
+    offered: pipelines.filter((p) => labelled(p) && listed(p) && suits(p)),
+    hiddenByPurpose: pipelines.filter((p) => labelled(p) && listed(p) && !suits(p)).length,
+    archivedInScope: pipelines.filter((p) => labelled(p) && suits(p) && p.archived).length,
+  }
+}

package/i18n/locales/de.json

@@ -4213,7 +4213,6 @@
       "strategy": "Strategie",
       "rounds": "Runden",
       "purposeLabel": "Zweck",
-      "purposePlaceholder": "Zweck auswählen",
       "purposeUnrecognized": "Nicht erkannt ({purpose})",
       "purposeOption": {
         "build": "Entwicklung",
@@ -4232,6 +4231,10 @@
       "removeParticipant": "Teilnehmer entfernen (min. 2)",
       "addParticipant": "Teilnehmer hinzufügen",
       "savedPipelines": "Gespeicherte Pipelines",
+      "purposeHiddenPipelines": "{count} gespeicherte Pipeline ist für diesen Zweck ausgeblendet. | {count} gespeicherte Pipelines sind für diesen Zweck ausgeblendet.",
+      "everyPurposeListed": "Gespeicherte Pipelines aller Zwecke werden aufgelistet.",
+      "listEveryPurpose": "Alle Zwecke anzeigen",
+      "narrowToDraftPurpose": "Auf diesen Zweck eingrenzen",
       "hideArchived": "Archivierte ausblenden",
       "archivedCount": "Archiviert ({count})",
       "allLabels": "Alle",

package/i18n/locales/en.json

@@ -4795,7 +4795,6 @@
       "strategy": "Strategy",
       "rounds": "Rounds",
       "purposeLabel": "Purpose",
-      "purposePlaceholder": "Select a purpose",
       "purposeUnrecognized": "Unrecognized ({purpose})",
       "@purposeUnrecognized": {
         "description": "Shown on the pipeline-purpose control when the pipeline carries a purpose this build has no label for (a member added by a newer build, or one since retired). The raw stored value is quoted back so it can be recognised and re-picked."
@@ -4817,6 +4816,13 @@
       "removeParticipant": "Remove participant (min 2)",
       "addParticipant": "Add participant",
       "savedPipelines": "Saved pipelines",
+      "purposeHiddenPipelines": "{count} saved pipeline hidden for this purpose. | {count} saved pipelines hidden for this purpose.",
+      "everyPurposeListed": "Listing saved pipelines for every purpose.",
+      "listEveryPurpose": "Show every purpose",
+      "narrowToDraftPurpose": "Narrow to this purpose",
+      "@purposeHiddenPipelines": {
+        "description": "Shown above the saved-pipeline list in the pipeline builder: how many saved pipelines are not listed because they were built for a different purpose than the one being edited."
+      },
       "hideArchived": "Hide archived",
       "archivedCount": "Archived ({count})",
       "allLabels": "All",

package/i18n/locales/es.json

@@ -4652,7 +4652,6 @@
       "strategy": "Estrategia",
       "rounds": "Rondas",
       "purposeLabel": "Propósito",
-      "purposePlaceholder": "Seleccionar un propósito",
       "purposeUnrecognized": "No reconocido ({purpose})",
       "purposeOption": {
         "build": "Desarrollo",
@@ -4671,6 +4670,10 @@
       "removeParticipant": "Quitar participante (mín. 2)",
       "addParticipant": "Añadir participante",
       "savedPipelines": "Pipelines guardados",
+      "purposeHiddenPipelines": "{count} pipeline guardado oculto para este propósito. | {count} pipelines guardados ocultos para este propósito.",
+      "everyPurposeListed": "Se muestran los pipelines guardados de todos los propósitos.",
+      "listEveryPurpose": "Mostrar todos los propósitos",
+      "narrowToDraftPurpose": "Limitar a este propósito",
       "hideArchived": "Ocultar archivados",
       "archivedCount": "Archivados ({count})",
       "allLabels": "Todas",

package/i18n/locales/fr.json

@@ -4652,7 +4652,6 @@
       "strategy": "Stratégie",
       "rounds": "Tours",
       "purposeLabel": "Objectif",
-      "purposePlaceholder": "Sélectionner un objectif",
       "purposeUnrecognized": "Non reconnu ({purpose})",
       "purposeOption": {
         "build": "Développement",
@@ -4671,6 +4670,10 @@
       "removeParticipant": "Retirer le participant (min. 2)",
       "addParticipant": "Ajouter un participant",
       "savedPipelines": "Pipelines enregistrés",
+      "purposeHiddenPipelines": "{count} pipeline enregistré masqué pour cet objectif. | {count} pipelines enregistrés masqués pour cet objectif.",
+      "everyPurposeListed": "Les pipelines enregistrés de tous les objectifs sont affichés.",
+      "listEveryPurpose": "Afficher tous les objectifs",
+      "narrowToDraftPurpose": "Limiter à cet objectif",
       "hideArchived": "Masquer les archivés",
       "archivedCount": "Archivés ({count})",
       "allLabels": "Toutes",

package/i18n/locales/he.json

@@ -4652,7 +4652,6 @@
       "strategy": "אסטרטגיה",
       "rounds": "סבבים",
       "purposeLabel": "מטרה",
-      "purposePlaceholder": "בחר מטרה",
       "purposeUnrecognized": "לא מזוהה ({purpose})",
       "purposeOption": {
         "build": "פיתוח",
@@ -4671,6 +4670,10 @@
       "removeParticipant": "הסר משתתף (מינימום 2)",
       "addParticipant": "הוסף משתתף",
       "savedPipelines": "צינורות שמורים",
+      "purposeHiddenPipelines": "צינור שמור אחד מוסתר עבור מטרה זו. | שני צינורות שמורים מוסתרים עבור מטרה זו. | {count} צינורות שמורים מוסתרים עבור מטרה זו.",
+      "everyPurposeListed": "מוצגים צינורות שמורים מכל המטרות.",
+      "listEveryPurpose": "הצג את כל המטרות",
+      "narrowToDraftPurpose": "צמצם למטרה זו",
       "hideArchived": "הסתר מאורכבים",
       "archivedCount": "מאורכבים ({count})",
       "allLabels": "הכל",

package/i18n/locales/it.json

@@ -4213,7 +4213,6 @@
       "strategy": "Strategia",
       "rounds": "Giri",
       "purposeLabel": "Scopo",
-      "purposePlaceholder": "Seleziona uno scopo",
       "purposeUnrecognized": "Non riconosciuto ({purpose})",
       "purposeOption": {
         "build": "Sviluppo",
@@ -4232,6 +4231,10 @@
       "removeParticipant": "Rimuovi partecipante (min 2)",
       "addParticipant": "Aggiungi partecipante",
       "savedPipelines": "Pipeline salvate",
+      "purposeHiddenPipelines": "{count} pipeline salvata nascosta per questo scopo. | {count} pipeline salvate nascoste per questo scopo.",
+      "everyPurposeListed": "Sono elencate le pipeline salvate di ogni scopo.",
+      "listEveryPurpose": "Mostra tutti gli scopi",
+      "narrowToDraftPurpose": "Limita a questo scopo",
       "hideArchived": "Nascondi archiviate",
       "archivedCount": "Archiviate ({count})",
       "allLabels": "Tutte",

package/i18n/locales/ja.json

@@ -4652,7 +4652,6 @@
       "strategy": "戦略",
       "rounds": "ラウンド",
       "purposeLabel": "目的",
-      "purposePlaceholder": "目的を選択",
       "purposeUnrecognized": "認識できません ({purpose})",
       "purposeOption": {
         "build": "開発",
@@ -4671,6 +4670,10 @@
       "removeParticipant": "参加者を削除(最低2)",
       "addParticipant": "参加者を追加",
       "savedPipelines": "保存済みパイプライン",
+      "purposeHiddenPipelines": "この目的では {count} 件の保存済みパイプラインが非表示です。",
+      "everyPurposeListed": "すべての目的の保存済みパイプラインを表示しています。",
+      "listEveryPurpose": "すべての目的を表示",
+      "narrowToDraftPurpose": "この目的に絞り込む",
       "hideArchived": "アーカイブを非表示",
       "archivedCount": "アーカイブ済み({count})",
       "allLabels": "すべて",

package/i18n/locales/pl.json

@@ -4652,7 +4652,6 @@
       "strategy": "Strategia",
       "rounds": "Rundy",
       "purposeLabel": "Cel",
-      "purposePlaceholder": "Wybierz cel",
       "purposeUnrecognized": "Nierozpoznany ({purpose})",
       "purposeOption": {
         "build": "Programowanie",
@@ -4671,6 +4670,10 @@
       "removeParticipant": "Usuń uczestnika (min. 2)",
       "addParticipant": "Dodaj uczestnika",
       "savedPipelines": "Zapisane pipeline'y",
+      "purposeHiddenPipelines": "{count} zapisany pipeline ukryty dla tego celu. | {count} zapisane pipeline'y ukryte dla tego celu. | {count} zapisanych pipeline'ów ukrytych dla tego celu.",
+      "everyPurposeListed": "Wyświetlane są zapisane pipeline'y wszystkich celów.",
+      "listEveryPurpose": "Pokaż wszystkie cele",
+      "narrowToDraftPurpose": "Zawęź do tego celu",
       "hideArchived": "Ukryj zarchiwizowane",
       "archivedCount": "Zarchiwizowane ({count})",
       "allLabels": "Wszystkie",

package/i18n/locales/tr.json

@@ -4652,7 +4652,6 @@
       "strategy": "Strateji",
       "rounds": "Tur",
       "purposeLabel": "Amaç",
-      "purposePlaceholder": "Bir amaç seçin",
       "purposeUnrecognized": "Tanınmayan ({purpose})",
       "purposeOption": {
         "build": "Geliştirme",
@@ -4671,6 +4670,10 @@
       "removeParticipant": "Katılımcıyı kaldır (en az 2)",
       "addParticipant": "Katılımcı ekle",
       "savedPipelines": "Kayıtlı pipeline'lar",
+      "purposeHiddenPipelines": "Bu amaç için {count} kayıtlı pipeline gizli.",
+      "everyPurposeListed": "Tüm amaçlara ait kayıtlı pipeline'lar listeleniyor.",
+      "listEveryPurpose": "Tüm amaçları göster",
+      "narrowToDraftPurpose": "Bu amaca daralt",
       "hideArchived": "Arşivlenenleri gizle",
       "archivedCount": "Arşivlenen ({count})",
       "allLabels": "Tümü",

package/i18n/locales/uk.json

@@ -4652,7 +4652,6 @@
       "strategy": "Стратегія",
       "rounds": "Раунди",
       "purposeLabel": "Призначення",
-      "purposePlaceholder": "Виберіть призначення",
       "purposeUnrecognized": "Нерозпізнано ({purpose})",
       "purposeOption": {
         "build": "Розробка",
@@ -4671,6 +4670,10 @@
       "removeParticipant": "Прибрати учасника (мін. 2)",
       "addParticipant": "Додати учасника",
       "savedPipelines": "Збережені пайплайни",
+      "purposeHiddenPipelines": "{count} збережений пайплайн приховано для цього призначення. | {count} збережені пайплайни приховано для цього призначення. | {count} збережених пайплайнів приховано для цього призначення.",
+      "everyPurposeListed": "Показано збережені пайплайни всіх призначень.",
+      "listEveryPurpose": "Показати всі призначення",
+      "narrowToDraftPurpose": "Звузити до цього призначення",
       "hideArchived": "Сховати архівовані",
       "archivedCount": "Архівовані ({count})",
       "allLabels": "Усі",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/app",
-  "version": "0.254.2",
+  "version": "0.255.0",
   "description": "Reusable Nuxt layer for the Agent Architecture Board SPA (components, stores, composables, pages). Consume it from a thin deployment app via `extends: ['@cat-factory/app']` and point it at your backend with NUXT_PUBLIC_API_BASE. See deploy/frontend for an example.",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "valibot": "^1.4.2",
     "vue": "3.5.40",
     "wretch": "^3.0.9",
-    "@cat-factory/contracts": "0.279.0"
+    "@cat-factory/contracts": "0.281.0"
   },
   "devDependencies": {
     "@toad-contracts/testing": "0.3.2",