@cat-factory/app 0.140.0 → 0.141.1

package/app/components/board/AddTaskModal.vue

@@ -288,17 +288,34 @@ const selectedModelPresetLabel = computed(() => {
 
 // Hide UI-testing pipelines (`tester-ui` / `visual-confirmation`) when the target frame has no
 // UI to exercise — they'd be refused server-side (see utils/pipeline + the backend gate). Also
-// hide `'recurring'`-only pipelines: a one-off task start of one is refused at run start.
+// hide `'recurring'`-only pipelines (a one-off task start of one is refused at run start) and,
+// for a `document` task, every non-document pipeline (it authors a doc — only document pipelines
+// are relevant, per the `purpose` classifier). Re-filters as the chosen task type changes.
 const selectablePipelines = computed(() =>
-  pipelines.pipelines.filter((p) => pipelineAllowedForManualStart(p, frame.value, board.blocks)),
+  pipelines.pipelines.filter((p) =>
+    pipelineAllowedForManualStart(p, frame.value, board.blocks, taskType.value),
+  ),
 )
-// Picking the Ralph loop task type auto-selects its pipeline, so the per-task validation
-// command + iteration budget (contributed by the `ralph` agent) surface immediately — the
-// loop is meaningless without them, so "choose at run time" would be a dead end here.
+// Some task types want their type-default pipeline surfaced in the modal up front, so picking the
+// type auto-selects it (the user can still change it among the still-offered pipelines). This is a
+// DELIBERATE SUBSET of the backend `defaultPipelineIdForTaskType` — only the types whose default
+// must appear in the form BEFORE creation:
+//   - `ralph` needs its preset so the per-task validation command + iteration budget the `ralph`
+//     agent contributes surface for editing ("choose at run time" would be a dead end);
+//   - a `document` task defaults to `pl_document` so its document-only picker (the `purpose` gate
+//     hides every non-document pipeline) is never rendered empty.
+// The other typed defaults (spike/review) carry no up-front config and don't narrow their picker,
+// so the modal leaves `pipelineId` unset and `BoardService` applies the backend type-default at
+// creation. Keep these ids in step with the backend helper.
+const DEFAULT_PIPELINE_FOR_TYPE: Partial<Record<TaskTypeChoice, string>> = {
+  ralph: 'pl_ralph',
+  document: 'pl_document',
+}
 watch(taskType, (next) => {
-  if (next !== 'ralph') return
-  const ralph = pipelines.pipelines.find((p) => p.id === 'pl_ralph')
-  if (ralph) pipelineId.value = ralph.id
+  const preset = DEFAULT_PIPELINE_FOR_TYPE[next]
+  if (!preset) return
+  const match = pipelines.pipelines.find((p) => p.id === preset)
+  if (match) pipelineId.value = match.id
 })
 
 // Task-level agent config contributed by the selected pipeline's agents (e.g. the
@@ -455,7 +472,10 @@ watch(open, (isOpen) => {
     delete docKindFieldValues[key]
   riskPolicyId.value = ''
   modelPresetId.value = ''
-  pipelineId.value = ''
+  // Seed the pipeline from the (possibly doc-repo-forced) task type's default, so a document
+  // repo opens with `pl_document` pre-selected rather than empty. This runs AFTER the `taskType`
+  // watcher fired during this reset, so it is the authoritative default (see DEFAULT_PIPELINE_FOR_TYPE).
+  pipelineId.value = DEFAULT_PIPELINE_FOR_TYPE[taskType.value] ?? ''
   agentConfigValues.value = {}
   pendingContext.value = []
   showDocPicker.value = false

package/app/components/documents/TaskContextDocs.vue

@@ -1,54 +1,70 @@
 <script setup lang="ts">
 import type { DropdownMenuItem } from '@nuxt/ui'
-import type { Block, DocumentSourceKind } from '~/types/domain'
+import type { Block } from '~/types/domain'
+import ContextDocumentPicker from '~/components/documents/ContextDocumentPicker.vue'
 import InspectorSection from '~/components/panels/inspector/InspectorSection.vue'
 
 // Documents (from any source) attached to a task as agent context, shown inside
-// the InspectorPanel. Linked docs are fed to agents during execution (see the
-// backend's userPromptFor). Rendered only when the integration is available.
+// the InspectorPanel. Attaching uses the SAME inline picker as task creation
+// (source selector + repo→file browse + free-text search + paste-by-reference —
+// ContextDocumentPicker), NOT the old dropdown that opened a second, page-level
+// "Import a page…" modal on top of the inspector. Stacked page-level modals don't
+// interact here, so that menu appeared to open something with nothing clickable.
+// Because the block already exists, a picked item is imported-when-needed then
+// linked immediately via useContextLinking (the add-task flow's shared
+// orchestration), so failures surface with their real cause. Mirrors
+// TaskContextIssues.vue; rendered only when the integration is available.
 const props = defineProps<{ block: Block }>()
 
 const { t } = useI18n()
 const documents = useDocumentsStore()
 const ui = useUiStore()
 const toast = useToast()
+const { linkPending, presentLinkFailures } = useContextLinking()
 
 onMounted(() => {
   documents.loadDocuments().catch(() => {})
 })
 
 const linked = computed(() => documents.docsForBlock(props.block.id))
+// Already-linked docs, so the inline picker filters them out / never re-offers them.
+const chosenKeys = computed(() =>
+  linked.value.map((d) =>
+    contextKey({ kind: 'document', source: d.source, externalId: d.externalId }),
+  ),
+)
 
-async function attach(source: DocumentSourceKind, externalId: string) {
+const connected = computed(() => documents.available && documents.anyConnected)
+// Sources the user could connect right now to unlock the picker, when none is
+// connected yet (GitHub docs are implicitly connected via the App, so never here).
+const connectableSources = computed(() =>
+  documents.available ? documents.sources.filter((s) => !documents.isConnected(s.source)) : [],
+)
+const connectMenu = computed<DropdownMenuItem[][]>(() => [
+  connectableSources.value.map((s) => ({
+    label: s.label,
+    icon: s.icon,
+    onSelect: () => ui.openDocumentConnect(s.source),
+  })),
+])
+
+const showPicker = ref(false)
+const linking = ref(false)
+
+// The block exists, so import-when-needed then link immediately (vs the add-task
+// flow which stages the pick and links after create). linkPending never throws —
+// it captures each failure with its cause for the shared presenter.
+async function attach(item: PendingContext) {
+  if (linking.value) return
+  linking.value = true
   try {
-    await documents.linkToBlock(props.block.id, source, externalId)
-    toast.add({ title: t('documents.taskDocs.attached'), icon: 'i-lucide-link' })
-  } catch (e) {
-    toast.add({
-      title: t('documents.taskDocs.attachFailed'),
-      description: e instanceof Error ? e.message : String(e),
-      icon: 'i-lucide-triangle-alert',
-      color: 'error',
-    })
+    const failures = await linkPending(props.block.id, [item])
+    if (failures.length) presentLinkFailures(failures, props.block.id)
+    else toast.add({ title: t('documents.taskDocs.attached'), icon: 'i-lucide-link' })
+  } finally {
+    linking.value = false
   }
 }
-
-const attachMenu = computed<DropdownMenuItem[][]>(() => {
-  const linkedKeys = new Set(linked.value.map((d) => `${d.source}:${d.externalId}`))
-  const items: DropdownMenuItem[] = documents.documents
-    .filter((d) => !linkedKeys.has(`${d.source}:${d.externalId}`))
-    .map((d) => ({
-      label: d.title,
-      icon: documents.descriptorFor(d.source)?.icon ?? 'i-lucide-file-text',
-      onSelect: () => attach(d.source, d.externalId),
-    }))
-  items.push({
-    label: t('documents.taskDocs.importPage'),
-    icon: 'i-lucide-file-down',
-    onSelect: () => ui.openDocumentImport(null),
-  })
-  return [items]
-})
 </script>
 
 <template>
@@ -59,13 +75,43 @@ const attachMenu = computed<DropdownMenuItem[][]>(() => {
     :count="linked.length"
   >
     <template #actions>
-      <UDropdownMenu :items="attachMenu" :content="{ side: 'bottom', align: 'end' }">
-        <UButton color="neutral" variant="soft" size="xs" icon="i-lucide-plus">{{
-          t('documents.taskDocs.attach')
-        }}</UButton>
+      <UButton
+        v-if="connected"
+        color="neutral"
+        variant="soft"
+        size="xs"
+        :icon="showPicker ? 'i-lucide-x' : 'i-lucide-plus'"
+        @click="showPicker = !showPicker"
+      >
+        {{ showPicker ? t('common.done') : t('documents.taskDocs.attach') }}
+      </UButton>
+      <UDropdownMenu
+        v-else-if="connectableSources.length > 1"
+        :items="connectMenu"
+        :content="{ side: 'bottom', align: 'end' }"
+      >
+        <UButton color="neutral" variant="soft" size="xs" icon="i-lucide-plug">
+          {{ t('documents.taskDocs.connectSource') }}
+        </UButton>
       </UDropdownMenu>
+      <UButton
+        v-else-if="connectableSources.length === 1"
+        color="neutral"
+        variant="soft"
+        size="xs"
+        icon="i-lucide-plug"
+        @click="ui.openDocumentConnect(connectableSources[0]!.source)"
+      >
+        {{ t('documents.taskDocs.connectSourceNamed', { source: connectableSources[0]!.label }) }}
+      </UButton>
     </template>
 
+    <ContextDocumentPicker
+      v-if="showPicker && connected"
+      :chosen-keys="chosenKeys"
+      @pick="attach"
+    />
+
     <div v-if="linked.length" class="space-y-1">
       <a
         v-for="doc in linked"

package/app/components/focus/BlockFocusView.vue

@@ -28,12 +28,13 @@ const deps = computed(() =>
   (block.value?.dependsOn ?? []).map((id) => board.getBlock(id)).filter((b): b is Block => !!b),
 )
 
-// Hide UI-testing pipelines when this block's frame has no UI to exercise, and `'recurring'`-only
-// pipelines (a manual run of one is refused server-side) — see the backend gate.
+// Hide UI-testing pipelines when this block's frame has no UI to exercise, `'recurring'`-only
+// pipelines (a manual run of one is refused server-side), and — for a `document` task — every
+// non-document pipeline (per the `purpose` classifier) — see the backend gate.
 const runMenu = computed(() => {
   const frame = block.value ? board.serviceOf(block.value) : undefined
   return pipelines.pipelines
-    .filter((p) => pipelineAllowedForManualStart(p, frame, board.blocks))
+    .filter((p) => pipelineAllowedForManualStart(p, frame, board.blocks, block.value?.taskType))
     .map((p) => ({
       label: p.name,
       icon: 'i-lucide-play',

package/app/components/palettes/AgentPalette.vue

@@ -1,21 +1,29 @@
 <script setup lang="ts">
 import { computed } from 'vue'
 import { useLocalStorage } from '@vueuse/core'
-import type { AgentKind } from '~/types/domain'
+import { purposeAllowsAgentCategory } from '@cat-factory/contracts'
+import type { AgentKind, PipelinePurpose } from '~/types/domain'
 import { AGENT_CATEGORIES, OBSERVABILITY_GATE_ARCHETYPE } from '~/utils/catalog'
 
 const { t } = useI18n()
 const agents = useAgentsStore()
 const releaseHealth = useReleaseHealthStore()
 defineEmits<{ (e: 'add', kind: AgentKind): void }>()
+// The purpose of the pipeline being built. When set to a non-`build` classifier, the
+// Implementation (`build`) and Testing (`test`) categories are hidden — such a pipeline writes
+// no product code and runs no tests (see `purposeAllowsAgentCategory`). `null`/`build` shows all.
+const props = defineProps<{ purpose?: PipelinePurpose | null }>()
 
 // 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.
-const palette = computed(() =>
-  releaseHealth.connection.connected
+const palette = computed(() => {
+  const all = releaseHealth.connection.connected
     ? [...agents.archetypes, OBSERVABILITY_GATE_ARCHETYPE]
-    : agents.archetypes,
-)
+    : agents.archetypes
+  // Hide the categories the pipeline's purpose doesn't build from (an uncategorized custom kind
+  // has no category to gate, so it always shows).
+  return all.filter((a) => !a.category || purposeAllowsAgentCategory(props.purpose, a.category))
+})
 
 // Group the palette into the ordered catalog categories, plus a trailing "Custom" bucket
 // for runtime-added agents that carry no category. Empty groups are dropped.

package/app/components/panels/inspector/TaskRunSettings.vue

@@ -133,13 +133,14 @@ function setModelPreset(id: string) {
 const selectedPipeline = computed(() =>
   props.block.pipelineId ? pipelines.getPipeline(props.block.pipelineId) : undefined,
 )
-// Hide UI-testing pipelines when this task's frame has no UI to exercise, and `'recurring'`-only
-// pipelines (the task's manual Run control can't start one) — they'd be refused at run start
-// (see utils/pipeline + the backend gate).
+// Hide UI-testing pipelines when this task's frame has no UI to exercise, `'recurring'`-only
+// pipelines (the task's manual Run control can't start one), and — for a `document` task — every
+// non-document pipeline (it authors a doc, so a build/test pipeline makes no sense). All would be
+// refused / wrong at run start (see utils/pipeline + the backend gate + the purpose classifier).
 const taskFrame = computed(() => board.serviceOf(props.block))
 const selectablePipelines = computed(() =>
   pipelines.pipelines.filter((p) =>
-    pipelineAllowedForManualStart(p, taskFrame.value, board.blocks),
+    pipelineAllowedForManualStart(p, taskFrame.value, board.blocks, props.block.taskType),
   ),
 )
 function setPipeline(id: string) {

package/app/components/pipeline/PipelineBuilder.vue

@@ -1,6 +1,7 @@
 <script setup lang="ts">
 import { computed, ref, watch } from 'vue'
-import type { AgentKind, Pipeline } from '~/types/domain'
+import { purposeAllowsAgentCategory } from '@cat-factory/contracts'
+import type { AgentKind, Pipeline, PipelinePurpose } from '~/types/domain'
 import AgentPalette from '~/components/palettes/AgentPalette.vue'
 import AgentKindIcon from '~/components/pipeline/AgentKindIcon.vue'
 import {
@@ -22,6 +23,18 @@ const CONSENSUS_STRATEGIES = computed<{ value: ConsensusStrategy; label: string
   { value: 'ranked-voting', label: t('pipeline.builder.strategyOption.ranked-voting') },
 ])
 
+// The use-case classifier options for the pipeline (its `purpose`). Static literal `t()` keys, one
+// per `PIPELINE_PURPOSES` member, so the typed-message-keys check sees them (a runtime-built key
+// wouldn't be checkable). A non-`build` purpose hides the Implementation/Testing agent kinds in
+// the palette below (see `AgentPalette`), and drives which task pickers offer the saved pipeline.
+const PURPOSE_OPTIONS = computed<{ value: PipelinePurpose; label: string }[]>(() => [
+  { value: 'build', label: t('pipeline.builder.purposeOption.build') },
+  { value: 'document', label: t('pipeline.builder.purposeOption.document') },
+  { value: 'review', label: t('pipeline.builder.purposeOption.review') },
+  { value: 'research', label: t('pipeline.builder.purposeOption.research') },
+  { value: 'planning', label: t('pipeline.builder.purposeOption.planning') },
+])
+
 /** Add a blank participant to the draft step's consensus config. */
 function addParticipant(i: number) {
   const cfg = pipelines.draftConsensus[i]
@@ -56,6 +69,19 @@ const skillStepNeedsPick = computed(() =>
   ),
 )
 
+// Steps whose agent category the chosen purpose forbids (a non-`build` purpose writes no code and
+// runs no tests, so the Implementation/Testing categories are disallowed — see
+// `purposeAllowsAgentCategory`). The palette hides those kinds, so this is only reachable by
+// switching an existing draft to a non-`build` purpose AFTER such steps were added. The backend has
+// no kind→category map to gate on, so the builder is the enforcement point: save is blocked until
+// the offending steps are removed (or the purpose set back to Build).
+const stepsDisallowedByPurpose = computed(() =>
+  pipelines.draft.filter((kind) => {
+    const category = agentKindMeta(kind).category
+    return !!category && !purposeAllowsAgentCategory(pipelines.draftPurpose, category)
+  }),
+)
+
 // A step's picked skill id is no longer in the account catalog (the source dir was renamed or
 // unlinked). The step will fail cleanly at dispatch; flag it so the user re-picks.
 function skillMissing(index: number): boolean {
@@ -282,7 +308,7 @@ async function clone(p: Pipeline) {
             </UButton>
           </div>
           <div class="flex-1 pe-1 lg:min-h-0 lg:overflow-y-auto">
-            <AgentPalette @add="add" />
+            <AgentPalette :purpose="pipelines.draftPurpose" @add="add" />
           </div>
         </div>
 
@@ -310,6 +336,24 @@ async function clone(p: Pipeline) {
             class="mb-2"
           />
 
+          <!-- Purpose: the pipeline's use-case classifier. Drives which task pickers offer it (a
+               document task offers only `document` pipelines) and narrows the palette below (a
+               non-build purpose hides the Implementation/Testing kinds). -->
+          <div class="mb-2 flex items-center gap-2">
+            <label class="shrink-0 text-[11px] font-medium text-slate-400">
+              {{ t('pipeline.builder.purposeLabel') }}
+            </label>
+            <USelect
+              :model-value="pipelines.draftPurpose ?? undefined"
+              :items="PURPOSE_OPTIONS"
+              value-key="value"
+              size="sm"
+              class="min-w-40"
+              :placeholder="t('pipeline.builder.purposePlaceholder')"
+              @update:model-value="pipelines.draftPurpose = $event"
+            />
+          </div>
+
           <!-- Description: the prose summary shown next to the step list in the pipeline pickers. -->
           <UTextarea
             v-model="pipelines.draftDescription"
@@ -360,6 +404,14 @@ async function clone(p: Pipeline) {
             {{ t('pipeline.builder.skillNeedsPick') }}
           </p>
 
+          <p
+            v-if="stepsDisallowedByPurpose.length"
+            class="mb-2 flex items-center gap-1.5 rounded-md border border-amber-800/50 bg-amber-950/30 px-2 py-1 text-[11px] text-amber-300"
+          >
+            <UIcon name="i-lucide-alert-triangle" class="h-3.5 w-3.5 shrink-0" />
+            {{ t('pipeline.builder.purposeStepsConflict') }}
+          </p>
+
           <div
             v-if="pipelines.draft.length === 0"
             class="flex flex-1 items-center justify-center rounded-lg border border-dashed border-slate-700 p-4 text-center text-xs text-slate-500"
@@ -1015,7 +1067,7 @@ async function clone(p: Pipeline) {
           color="primary"
           icon="i-lucide-save"
           size="sm"
-          :disabled="pipelines.draft.length === 0"
+          :disabled="pipelines.draft.length === 0 || stepsDisallowedByPurpose.length > 0"
           @click="save"
         >
           {{ pipelines.editingId ? t('pipeline.builder.update') : t('pipeline.builder.save') }}

package/app/components/tasks/TaskContextIssues.vue

@@ -1,11 +1,18 @@
 <script setup lang="ts">
-// Inspector section for a task block: the tracker issues (Jira, …) attached to
-// it as agent context, plus an "Attach" menu to link an already-imported issue
-// or open the import modal. Mirrors TaskContextDocs.vue; shown only when the
-// task-source integration is available. Each linked issue shows its status so
-// the structured nature of an issue is visible at a glance.
+// Inspector section for a task block: the tracker issues (Jira, GitHub Issues, …)
+// attached to it as agent context. Attaching uses the SAME inline picker as task
+// creation (source selector + in-repo search + paste-by-reference —
+// ContextIssuePicker), NOT the old dropdown that opened a second, page-level
+// "Import an issue…" modal on top of the inspector (stacked page-level modals
+// don't interact here, so the menu appeared to open something with nothing
+// clickable). Because the block already exists, a picked item is
+// imported-when-needed then linked immediately via useContextLinking, scoped to
+// this block's repo. Mirrors TaskContextDocs.vue; shown only when the task-source
+// integration is available. Each linked issue shows its status so the structured
+// nature of an issue is visible at a glance.
 import type { DropdownMenuItem } from '@nuxt/ui'
-import type { Block, TaskSourceKind } from '~/types/domain'
+import type { Block } from '~/types/domain'
+import ContextIssuePicker from '~/components/tasks/ContextIssuePicker.vue'
 import InspectorSection from '~/components/panels/inspector/InspectorSection.vue'
 
 const props = defineProps<{ block: Block }>()
@@ -14,43 +21,50 @@ const { t } = useI18n()
 const tasks = useTasksStore()
 const ui = useUiStore()
 const toast = useToast()
+const { linkPending, presentLinkFailures } = useContextLinking()
 
 onMounted(() => {
   tasks.loadTasks().catch(() => {})
 })
 
 const linked = computed(() => tasks.tasksForBlock(props.block.id))
+// Already-linked issues, so the inline picker filters them out / never re-offers them.
+const chosenKeys = computed(() =>
+  linked.value.map((issue) =>
+    contextKey({ kind: 'task', source: issue.source, externalId: issue.externalId }),
+  ),
+)
 
-async function attach(source: TaskSourceKind, externalId: string) {
+const connected = computed(() => tasks.available && tasks.anyOffered)
+// Trackers the user could connect right now to unlock the picker, when none is offered yet.
+const connectableSources = computed(() =>
+  tasks.available ? tasks.sources.filter((s) => !s.available) : [],
+)
+const connectMenu = computed<DropdownMenuItem[][]>(() => [
+  connectableSources.value.map((s) => ({
+    label: s.label,
+    icon: s.icon,
+    onSelect: () => ui.openTaskConnect(s.source),
+  })),
+])
+
+const showPicker = ref(false)
+const linking = ref(false)
+
+// The block exists, so import-when-needed then link immediately (vs the add-task
+// flow which stages the pick and links after create). linkPending never throws —
+// it captures each failure with its cause for the shared presenter.
+async function attach(item: PendingContext) {
+  if (linking.value) return
+  linking.value = true
   try {
-    await tasks.linkToBlock(props.block.id, source, externalId)
-    toast.add({ title: t('tasks.contextIssues.attached'), icon: 'i-lucide-link' })
-  } catch (e) {
-    toast.add({
-      title: t('tasks.contextIssues.attachFailed'),
-      description: e instanceof Error ? e.message : String(e),
-      icon: 'i-lucide-triangle-alert',
-      color: 'error',
-    })
+    const failures = await linkPending(props.block.id, [item])
+    if (failures.length) presentLinkFailures(failures, props.block.id)
+    else toast.add({ title: t('tasks.contextIssues.attached'), icon: 'i-lucide-link' })
+  } finally {
+    linking.value = false
   }
 }
-
-const attachMenu = computed<DropdownMenuItem[][]>(() => {
-  const linkedKeys = new Set(linked.value.map((t) => `${t.source}:${t.externalId}`))
-  const items: DropdownMenuItem[] = tasks.tasks
-    .filter((t) => !linkedKeys.has(`${t.source}:${t.externalId}`))
-    .map((t) => ({
-      label: `${t.externalId} · ${t.title}`,
-      icon: tasks.descriptorFor(t.source)?.icon ?? 'i-lucide-square-check',
-      onSelect: () => attach(t.source, t.externalId),
-    }))
-  items.push({
-    label: t('tasks.contextIssues.importIssue'),
-    icon: 'i-lucide-file-down',
-    onSelect: () => ui.openTaskImport(),
-  })
-  return [items]
-})
 </script>
 
 <template>
@@ -61,29 +75,60 @@ const attachMenu = computed<DropdownMenuItem[][]>(() => {
     :count="linked.length"
   >
     <template #actions>
-      <UDropdownMenu :items="attachMenu" :content="{ side: 'bottom', align: 'end' }">
-        <UButton color="neutral" variant="soft" size="xs" icon="i-lucide-plus">{{
-          t('tasks.contextIssues.attach')
-        }}</UButton>
+      <UButton
+        v-if="connected"
+        color="neutral"
+        variant="soft"
+        size="xs"
+        :icon="showPicker ? 'i-lucide-x' : 'i-lucide-plus'"
+        @click="showPicker = !showPicker"
+      >
+        {{ showPicker ? t('common.done') : t('tasks.contextIssues.attach') }}
+      </UButton>
+      <UDropdownMenu
+        v-else-if="connectableSources.length > 1"
+        :items="connectMenu"
+        :content="{ side: 'bottom', align: 'end' }"
+      >
+        <UButton color="neutral" variant="soft" size="xs" icon="i-lucide-plug">
+          {{ t('tasks.contextIssues.connectSource') }}
+        </UButton>
       </UDropdownMenu>
+      <UButton
+        v-else-if="connectableSources.length === 1"
+        color="neutral"
+        variant="soft"
+        size="xs"
+        icon="i-lucide-plug"
+        @click="ui.openTaskConnect(connectableSources[0]!.source)"
+      >
+        {{ t('tasks.contextIssues.connectSourceNamed', { source: connectableSources[0]!.label }) }}
+      </UButton>
     </template>
 
+    <ContextIssuePicker
+      v-if="showPicker && connected"
+      :chosen-keys="chosenKeys"
+      :scope-block-id="block.id"
+      @pick="attach"
+    />
+
     <div v-if="linked.length" class="space-y-1">
       <a
-        v-for="task in linked"
-        :key="`${task.source}:${task.externalId}`"
-        :href="task.url"
+        v-for="issue in linked"
+        :key="`${issue.source}:${issue.externalId}`"
+        :href="issue.url"
         target="_blank"
         rel="noopener"
         class="flex items-center gap-1.5 rounded-md border border-slate-800 bg-slate-900/60 px-2 py-1.5 text-xs text-slate-300 hover:bg-slate-800/60"
       >
         <UIcon
-          :name="tasks.descriptorFor(task.source)?.icon ?? 'i-lucide-square-check'"
+          :name="tasks.descriptorFor(issue.source)?.icon ?? 'i-lucide-square-check'"
           class="h-3.5 w-3.5 shrink-0 text-indigo-400"
         />
-        <span class="truncate">{{ task.externalId }} · {{ task.title }}</span>
+        <span class="truncate">{{ issue.externalId }} · {{ issue.title }}</span>
         <UBadge color="neutral" variant="soft" size="xs" class="ms-auto shrink-0">
-          {{ task.status }}
+          {{ issue.status }}
         </UBadge>
       </a>
     </div>

package/app/stores/pipelines.ts

@@ -2,7 +2,7 @@ import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
 import type { AgentKind, Pipeline } from '~/types/domain'
 import type { ConsensusStepConfig, StepGating } from '~/types/consensus'
-import type { StepOptions, TesterQualityConfig } from '@cat-factory/contracts'
+import type { PipelinePurpose, StepOptions, TesterQualityConfig } from '@cat-factory/contracts'
 import { companionForProducer, uid } from '~/utils/catalog'
 import { useUpsertList } from '~/composables/useUpsertList'
 import { useWorkspaceStore } from '~/stores/workspace'
@@ -81,6 +81,13 @@ export const usePipelinesStore = defineStore('pipelines', () => {
   const draftStepOptions = ref<(StepOptions | null)[]>([])
   /** Organizational labels for the pipeline being assembled/edited. */
   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).
+   */
+  const draftPurpose = ref<PipelinePurpose | null>(null)
   const draftName = ref('New pipeline')
   /** Prose description for the pipeline being assembled/edited (shown in the pickers). */
   const draftDescription = ref('')
@@ -323,6 +330,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftTesterQuality.value = []
     draftStepOptions.value = []
     draftLabels.value = []
+    draftPurpose.value = null
     draftName.value = 'New pipeline'
     draftDescription.value = ''
     editingId.value = null
@@ -342,6 +350,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     )
     draftStepOptions.value = pipeline.agentKinds.map((_, i) => pipeline.stepOptions?.[i] ?? null)
     draftLabels.value = [...(pipeline.labels ?? [])]
+    draftPurpose.value = pipeline.purpose ?? null
     draftName.value = pipeline.name
     draftDescription.value = pipeline.description ?? ''
     editingId.value = pipeline.id
@@ -389,6 +398,10 @@ export const usePipelinesStore = defineStore('pipelines', () => {
       stepOptions: draftStepOptions.value.map((o) => o ?? null),
       // Only send labels when there are any.
       ...(draftLabels.value.length ? { labels: [...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).
+      ...(draftPurpose.value ? { purpose: draftPurpose.value } : {}),
     }
   }
 
@@ -459,6 +472,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftTesterQuality,
     draftStepOptions,
     draftLabels,
+    draftPurpose,
     draftName,
     draftDescription,
     editingId,

package/app/types/domain.ts

@@ -60,6 +60,7 @@ export type {
   AgentCategory,
   CustomAgentKind,
   Pipeline,
+  PipelinePurpose,
   SpendStatus,
   BudgetCaps,
   Workspace,