@cat-factory/app 0.139.0 → 0.140.0

package/app/components/pipeline/PipelineBuilder.vue

@@ -310,6 +310,16 @@ async function clone(p: Pipeline) {
             class="mb-2"
           />
 
+          <!-- Description: the prose summary shown next to the step list in the pipeline pickers. -->
+          <UTextarea
+            v-model="pipelines.draftDescription"
+            :placeholder="t('pipeline.builder.descriptionPlaceholder')"
+            :rows="2"
+            autoresize
+            size="sm"
+            class="mb-2 w-full"
+          />
+
           <!-- Labels: organize the pipeline in the library (filter/search). -->
           <div class="mb-3 flex flex-wrap items-center gap-1.5">
             <UBadge

package/app/components/pipeline/PipelinePicker.vue

@@ -0,0 +1,120 @@
+<script setup lang="ts">
+// The rich pipeline picker used wherever a pipeline is chosen (add-task modal, inspector run
+// settings). A master–detail popover: the left column lists the selectable pipelines (plus a
+// "none / choose at run time" row), and hovering a row reveals that pipeline's full preview — its
+// description + the ordered agent steps — in the right column, so a user sees exactly what a
+// pipeline does before picking it. The trigger is customizable via the `#trigger` slot (the
+// inspector uses a bare icon button; the modal a full-width labelled one).
+import { computed, ref } from 'vue'
+import type { Pipeline } from '~/types/domain'
+
+const props = withDefaults(
+  defineProps<{
+    /** Selected pipeline id, or '' for the "none" option. */
+    modelValue: string
+    /** The pipelines offered (already filtered for the surface, e.g. manual-start allowed). */
+    options: Pipeline[]
+    /** Label for the "none" row (e.g. "Choose at run time" / "No default"). */
+    noneLabel: string
+    /** Extra classes for the default trigger button (e.g. full-width in the modal). */
+    triggerClass?: string
+  }>(),
+  { triggerClass: '' },
+)
+
+const emit = defineEmits<{ 'update:modelValue': [string] }>()
+const { t } = useI18n()
+
+const open = ref(false)
+// The row currently hovered, driving the right-column preview. `undefined` ⇒ fall back to the
+// selected pipeline; the sentinel '' means the "none" row is hovered (show the none hint).
+const hoverId = ref<string | undefined>(undefined)
+
+const selected = computed(() => props.options.find((p) => p.id === props.modelValue))
+const triggerLabel = computed(() => selected.value?.name ?? props.noneLabel)
+
+/** The pipeline the right pane previews: the hovered row, else the current selection. */
+const previewPipeline = computed<Pipeline | null>(() => {
+  const id = hoverId.value ?? props.modelValue
+  return id ? (props.options.find((p) => p.id === id) ?? null) : null
+})
+
+function choose(id: string) {
+  emit('update:modelValue', id)
+  open.value = false
+}
+</script>
+
+<template>
+  <UPopover v-model:open="open" :content="{ align: 'start' }">
+    <slot name="trigger" :label="triggerLabel">
+      <UButton
+        color="neutral"
+        variant="subtle"
+        size="sm"
+        icon="i-lucide-workflow"
+        trailing-icon="i-lucide-chevron-down"
+        :class="triggerClass"
+        data-testid="pipeline-picker-trigger"
+      >
+        {{ triggerLabel }}
+      </UButton>
+    </slot>
+
+    <template #content>
+      <div
+        class="flex max-h-[24rem] w-[min(44rem,94vw)]"
+        data-testid="pipeline-picker-panel"
+        @mouseleave="hoverId = undefined"
+      >
+        <!-- left: selectable options -->
+        <ul class="w-1/2 shrink-0 overflow-y-auto border-e border-slate-800 p-1">
+          <li>
+            <button
+              type="button"
+              class="flex w-full items-center gap-2 rounded px-2 py-1.5 text-start text-sm hover:bg-slate-800/60"
+              :class="modelValue ? 'text-slate-300' : 'text-slate-100'"
+              data-testid="pipeline-option-none"
+              @mouseenter="hoverId = ''"
+              @click="choose('')"
+            >
+              <UIcon name="i-lucide-rotate-ccw" class="h-4 w-4 shrink-0 text-slate-400" />
+              <span class="flex-1 truncate">{{ noneLabel }}</span>
+              <UIcon
+                v-if="!modelValue"
+                name="i-lucide-check"
+                class="h-4 w-4 shrink-0 text-primary-400"
+              />
+            </button>
+          </li>
+          <li v-for="p in options" :key="p.id">
+            <button
+              type="button"
+              class="flex w-full items-center gap-2 rounded px-2 py-1.5 text-start text-sm hover:bg-slate-800/60"
+              :class="modelValue === p.id ? 'text-slate-100' : 'text-slate-300'"
+              :data-testid="`pipeline-option-${p.id}`"
+              @mouseenter="hoverId = p.id"
+              @click="choose(p.id)"
+            >
+              <UIcon name="i-lucide-workflow" class="h-4 w-4 shrink-0 text-slate-400" />
+              <span class="flex-1 truncate">{{ p.name }}</span>
+              <UIcon
+                v-if="modelValue === p.id"
+                name="i-lucide-check"
+                class="h-4 w-4 shrink-0 text-primary-400"
+              />
+            </button>
+          </li>
+        </ul>
+
+        <!-- right: preview of the hovered (or selected) pipeline -->
+        <div class="w-1/2 overflow-y-auto p-3">
+          <PipelinePreview v-if="previewPipeline" :pipeline="previewPipeline" />
+          <div v-else class="text-[12px] leading-snug text-slate-500">
+            {{ t('pipeline.picker.noneHint') }}
+          </div>
+        </div>
+      </div>
+    </template>
+  </UPopover>
+</template>

package/app/components/pipeline/PipelinePreview.vue

@@ -0,0 +1,49 @@
+<script setup lang="ts">
+// A compact, read-only summary of a pipeline: its name, prose description (when authored), and the
+// ordered list of enabled agent steps rendered as icon+label chips (a human-gated step is flagged).
+// Shared by the pipeline pickers' hover preview so "what a pipeline consists of" is explained the
+// same way everywhere. Resolves each step's display metadata through the single `agentKindMeta`
+// path (via <AgentKindIcon>), so a system/custom kind can never blow up the renderer.
+import { computed } from 'vue'
+import type { Pipeline } from '~/types/domain'
+import { pipelineDisplaySteps } from '~/utils/pipeline'
+
+const props = defineProps<{ pipeline: Pipeline }>()
+const { t } = useI18n()
+
+const steps = computed(() => pipelineDisplaySteps(props.pipeline))
+</script>
+
+<template>
+  <div class="space-y-2" data-testid="pipeline-preview">
+    <div class="text-sm font-semibold text-slate-100">{{ pipeline.name }}</div>
+    <p
+      v-if="pipeline.description"
+      class="text-[12px] leading-snug text-slate-400"
+      data-testid="pipeline-preview-description"
+    >
+      {{ pipeline.description }}
+    </p>
+    <div>
+      <div class="mb-1 flex items-center gap-1 text-[10px] uppercase tracking-wide text-slate-500">
+        <UIcon name="i-lucide-workflow" class="h-3 w-3" />
+        {{ t('pipeline.preview.stepCount', { count: steps.length }, steps.length) }}
+      </div>
+      <ol class="flex flex-wrap items-center gap-1">
+        <li
+          v-for="(s, i) in steps"
+          :key="i"
+          class="inline-flex items-center gap-1 rounded bg-slate-800/70 px-1.5 py-0.5"
+        >
+          <AgentKindIcon :kind="s.kind" show-label icon-class="h-3.5 w-3.5" />
+          <UIcon
+            v-if="s.gated"
+            name="i-lucide-shield-check"
+            class="h-3 w-3 text-amber-400"
+            :title="t('pipeline.preview.gated')"
+          />
+        </li>
+      </ol>
+    </div>
+  </div>
+</template>

package/app/composables/api/github.ts

@@ -13,6 +13,7 @@ import {
   listGitHubIssuesContract,
   listGitHubPullsContract,
   listGitHubReposContract,
+  listGitHubRepoFilesContract,
   listGitHubRepoTreeContract,
   mergeGitHubPullRequestContract,
   openGitHubPullRequestContract,
@@ -92,6 +93,13 @@ export function githubApi({ send, ws }: ApiContext) {
         queryParams: { path },
       }),
 
+    // List every file in a repo (whole tree, one recursive read) for file-path search.
+    listGitHubRepoFiles: (workspaceId: string, repoGithubId: number) =>
+      send(listGitHubRepoFilesContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { repoGithubId: String(repoGithubId) },
+      }),
+
     listGitHubBranches: (workspaceId: string, repoGithubId: number) =>
       send(listGitHubBranchesContract, {
         pathPrefix: ws(workspaceId),

package/app/composables/useContextLinking.spec.ts

@@ -0,0 +1,138 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+  buildLinkFailureReport,
+  contextKey,
+  type LinkFailure,
+  type PendingContext,
+  useContextLinking,
+} from '~/composables/useContextLinking'
+
+// The context-linking path used to swallow every attachment failure into a bare count.
+// `buildLinkFailureReport` is the pure diagnostic dump the "Copy details" toast action
+// puts on the clipboard, so it must carry the item coordinates, the HTTP status + backend
+// code, and the server's message — the exact context a bug report needs.
+
+function item(overrides: Partial<PendingContext> = {}): PendingContext {
+  return {
+    kind: 'document',
+    source: 'github',
+    externalId: 'acme/repo:docs/x.md',
+    title: 'x.md',
+    needsImport: true,
+    ...overrides,
+  }
+}
+
+describe('buildLinkFailureReport', () => {
+  it('captures every failure with its coordinates, status, code, and message', () => {
+    const failures: LinkFailure[] = [
+      {
+        item: item(),
+        message: 'GitHub denied access to "docs/x.md" in acme/repo (HTTP 403).',
+        status: 403,
+        code: 'conflict',
+      },
+    ]
+
+    const report = buildLinkFailureReport(failures, {
+      workspaceId: 'ws_1',
+      blockId: 'blk_1',
+      when: '2026-07-19T00:00:00.000Z',
+    })
+
+    expect(report).toContain('Context link failures: 1')
+    expect(report).toContain('workspace: ws_1')
+    expect(report).toContain('block: blk_1')
+    expect(report).toContain('document/github: acme/repo:docs/x.md')
+    expect(report).toContain('status: 403')
+    expect(report).toContain('code: conflict')
+    expect(report).toContain('error: GitHub denied access')
+  })
+
+  it('omits absent optional fields (no status/code/context)', () => {
+    const report = buildLinkFailureReport([{ item: item(), message: 'network error' }])
+    expect(report).toContain('Context link failures: 1')
+    expect(report).not.toContain('status:')
+    expect(report).not.toContain('code:')
+    expect(report).not.toContain('workspace:')
+    expect(report).toContain('error: network error')
+  })
+
+  it('dumps the backend details bag, distinguishing the upstream status from the HTTP status', () => {
+    const report = buildLinkFailureReport([
+      {
+        item: item(),
+        message: 'GitHub denied access to "docs/x.md" in acme/repo (HTTP 403).',
+        status: 409,
+        code: 'conflict',
+        details: { owner: 'acme', repo: 'repo', path: 'docs/x.md', status: 403 },
+      },
+    ])
+    // The mapped HTTP status and the upstream GitHub status are both present, unambiguously.
+    expect(report).toContain('status: 409')
+    expect(report).toContain('details.status: 403')
+    expect(report).toContain('details.owner: acme')
+    expect(report).toContain('details.path: docs/x.md')
+  })
+})
+
+describe('contextKey', () => {
+  it('is stable and distinguishes kind/source/externalId', () => {
+    expect(contextKey(item())).toBe('document:github:acme/repo:docs/x.md')
+    expect(contextKey(item({ kind: 'task', source: 'github' }))).toBe(
+      'task:github:acme/repo:docs/x.md',
+    )
+  })
+})
+
+describe('presentLinkFailures', () => {
+  // Stub the Nuxt auto-imports `useContextLinking` pulls in, so the toast-orchestration
+  // side of the composable can be exercised without a full Nuxt runtime.
+  function stub() {
+    const add = vi.fn()
+    // `copyAction` echoes the text it would copy so we can assert the report content.
+    const copyAction = vi.fn((text: string) => ({ label: 'copy', text, onClick: () => {} }))
+    vi.stubGlobal('useDocumentsStore', () => ({}))
+    vi.stubGlobal('useTasksStore', () => ({}))
+    vi.stubGlobal('useWorkspaceStore', () => ({ workspaceId: 'ws_1' }))
+    vi.stubGlobal('useToast', () => ({ add }))
+    vi.stubGlobal('useI18n', () => ({ t: (key: string) => key }))
+    vi.stubGlobal('useCopyToClipboard', () => ({ copyAction }))
+    return { add, copyAction }
+  }
+
+  afterEach(() => vi.unstubAllGlobals())
+
+  it('is a no-op when nothing failed', () => {
+    const { add } = stub()
+    useContextLinking().presentLinkFailures([])
+    expect(add).not.toHaveBeenCalled()
+  })
+
+  it('raises one sticky, actionable toast whose Copy action carries the full report', () => {
+    const { add, copyAction } = stub()
+    const failures: LinkFailure[] = [
+      {
+        item: item(),
+        message: 'GitHub denied access to "docs/x.md" in acme/repo (HTTP 403).',
+        status: 409,
+        code: 'conflict',
+        details: { owner: 'acme', repo: 'repo', path: 'docs/x.md', status: 403 },
+      },
+    ]
+    useContextLinking().presentLinkFailures(failures, 'blk_1')
+
+    expect(add).toHaveBeenCalledTimes(1)
+    const toast = add.mock.calls[0]![0]
+    // Sticky so the cause stays readable, titled by the count key, and per-item reason shown.
+    expect(toast.title).toBe('board.addTask.linkFailed')
+    expect(toast.duration).toBe(0)
+    expect(toast.description).toContain('GitHub denied access')
+    expect(toast.actions).toHaveLength(1)
+    // The Copy action's payload is the full diagnostic report (block + upstream status).
+    const report = copyAction.mock.calls[0]![0]
+    expect(report).toContain('block: blk_1')
+    expect(report).toContain('details.status: 403')
+    expect(toast.actions[0]).toMatchObject({ text: report })
+  })
+})

package/app/composables/useContextLinking.ts

@@ -1,4 +1,5 @@
 import type { DocumentSourceKind, TaskSourceKind } from '~/types/domain'
+import { apiErrorEnvelope, apiErrorStatus } from './api/errors'
 
 // Shared model + orchestration for attaching external context (imported docs and
 // tracker issues) to a board block. A "pending" item is something the user has
@@ -30,22 +31,96 @@ export interface PendingContext {
   needsImport: boolean
 }
 
+/**
+ * A single pending attachment that failed to import or link, captured with its
+ * actual cause instead of swallowed. The message is the server's own explanation
+ * (e.g. "GitHub denied access to …" / "… was not found on the default branch"),
+ * the status is the HTTP code, and the code is the backend error code
+ * (`conflict` / `validation` / …) — enough to both display a specific reason and
+ * assemble a copy-pasteable diagnostic report.
+ */
+export interface LinkFailure {
+  item: PendingContext
+  /** The server's message (or a network-fault message) explaining why it failed. */
+  message: string
+  /** HTTP status of the failed request, when the error carried one. */
+  status?: number
+  /** Backend error code (`conflict` / `validation` / …), when present. */
+  code?: string
+  /**
+   * The backend error envelope's `details` bag, when present — for a GitHub doc read
+   * this carries the repo coordinates + the UPSTREAM GitHub status (e.g. `status: 403`),
+   * which differs from the HTTP `status` above (the mapped response code, e.g. 409). Kept
+   * so the diagnostic report shows the real GitHub status, not just the mapped one.
+   */
+  details?: Record<string, unknown>
+}
+
 /** Stable key for a pending item, used for dedupe + selection toggles. */
 export function contextKey(c: Pick<PendingContext, 'kind' | 'source' | 'externalId'>): string {
   return `${c.kind}:${c.source}:${c.externalId}`
 }
 
+/**
+ * Render a batch of {@link LinkFailure}s into a single plain-text diagnostic block
+ * for the clipboard — the exact context a bug report needs (the item coordinates,
+ * the HTTP status + backend code, the backend `details` bag, and the server's message)
+ * so the user does not have to retype any of it. Deliberately English/technical (a log
+ * dump, not UI prose), mirroring how format/code examples stay out of the i18n catalog.
+ */
+export function buildLinkFailureReport(
+  failures: LinkFailure[],
+  context: { workspaceId?: string | null; blockId?: string; when?: string } = {},
+): string {
+  const lines: string[] = []
+  lines.push(`Context link failures: ${failures.length}`)
+  if (context.when) lines.push(`when: ${context.when}`)
+  if (context.workspaceId) lines.push(`workspace: ${context.workspaceId}`)
+  if (context.blockId) lines.push(`block: ${context.blockId}`)
+  for (const f of failures) {
+    lines.push('')
+    lines.push(`- ${f.item.kind}/${f.item.source}: ${f.item.externalId}`)
+    lines.push(`  title: ${f.item.title}`)
+    if (f.status !== undefined) lines.push(`  status: ${f.status}`)
+    if (f.code) lines.push(`  code: ${f.code}`)
+    // Dump the backend `details` (repo coordinates + upstream status), each key namespaced
+    // so its `status` reads clearly as the GitHub status, distinct from the HTTP `status`.
+    for (const [key, value] of Object.entries(f.details ?? {})) {
+      lines.push(`  details.${key}: ${formatDetailValue(value)}`)
+    }
+    lines.push(`  error: ${f.message}`)
+  }
+  return lines.join('\n')
+}
+
+/** One-line rendering of a `details` value for the diagnostic dump (objects → JSON). */
+function formatDetailValue(value: unknown): string {
+  if (value === null || value === undefined) return String(value)
+  if (typeof value === 'object') {
+    try {
+      return JSON.stringify(value)
+    } catch {
+      return String(value)
+    }
+  }
+  return String(value)
+}
+
 export function useContextLinking() {
   const documents = useDocumentsStore()
   const tasks = useTasksStore()
+  const workspace = useWorkspaceStore()
+  const toast = useToast()
+  const { t } = useI18n()
+  const { copyAction } = useCopyToClipboard()
 
   /**
    * Import (when needed) then link every pending item to `blockId`. Each failure
-   * is counted rather than aborting the batch, so one bad attachment doesn't sink
-   * the rest; returns how many failed.
+   * is captured with its actual cause rather than aborting the batch, so one bad
+   * attachment doesn't sink the rest; returns the failures (empty ⇒ all linked).
    */
-  async function linkPending(blockId: string, items: PendingContext[]): Promise<number> {
-    let failed = 0
+  async function linkPending(blockId: string, items: PendingContext[]): Promise<LinkFailure[]> {
+    const failures: LinkFailure[] = []
     for (const item of items) {
       try {
         if (item.kind === 'document') {
@@ -61,12 +136,49 @@ export function useContextLinking() {
             : item.externalId
           await tasks.linkToBlock(blockId, source, externalId)
         }
-      } catch {
-        failed++
+      } catch (e) {
+        // Never swallow the cause: capture the server's own message + status/code/details
+        // so the toast can name the specific reason and the copy affordance can carry the
+        // full context (incl. the upstream GitHub status the backend puts on `details`).
+        const envelope = apiErrorEnvelope(e)
+        failures.push({
+          item,
+          message: e instanceof Error ? e.message : String(e),
+          status: apiErrorStatus(e),
+          code: envelope?.code,
+          details:
+            envelope?.details && typeof envelope.details === 'object'
+              ? (envelope.details as Record<string, unknown>)
+              : undefined,
+        })
       }
     }
-    return failed
+    return failures
+  }
+
+  /**
+   * Surface link failures as a single actionable toast: the specific per-item
+   * reasons as the body, and a "Copy details" action that puts the full diagnostic
+   * report ({@link buildLinkFailureReport}) on the clipboard. Sticky (`duration: 0`)
+   * so the cause stays readable long enough to act on. No-op when nothing failed.
+   */
+  function presentLinkFailures(failures: LinkFailure[], blockId?: string): void {
+    if (failures.length === 0) return
+    const description = failures.map((f) => `${f.item.title}: ${f.message}`).join('\n')
+    const report = buildLinkFailureReport(failures, {
+      workspaceId: workspace.workspaceId,
+      blockId,
+      when: new Date().toISOString(),
+    })
+    toast.add({
+      title: t('board.addTask.linkFailed', { count: failures.length }, failures.length),
+      description,
+      icon: 'i-lucide-triangle-alert',
+      color: 'warning',
+      duration: 0,
+      actions: [copyAction(report)],
+    })
   }
 
-  return { linkPending }
+  return { linkPending, presentLinkFailures }
 }

package/app/composables/useCopyToClipboard.spec.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it, vi } from 'vitest'
+
+// `useCopyToClipboard` wraps VueUse's clipboard; mock it so `copyAction` can be exercised
+// without a real clipboard. The global `useToast`/`useI18n` stubs come from test/setup.ts
+// (`t` echoes the key), so the default label resolves to its i18n key.
+const { writeClipboard } = vi.hoisted(() => ({ writeClipboard: vi.fn(async () => {}) }))
+vi.mock('@vueuse/core', () => ({
+  useClipboard: () => ({ copy: writeClipboard, isSupported: { value: true } }),
+}))
+
+import { useCopyToClipboard } from '~/composables/useCopyToClipboard'
+
+describe('copyAction', () => {
+  it('builds a Copy-details toast action that copies the given text', async () => {
+    const action = useCopyToClipboard().copyAction('diagnostic report')
+    expect(action.label).toBe('common.copyDetails')
+    expect(action.icon).toBe('i-lucide-clipboard')
+
+    action.onClick()
+    await Promise.resolve()
+    expect(writeClipboard).toHaveBeenCalledWith('diagnostic report')
+  })
+
+  it('honours a custom label', () => {
+    expect(useCopyToClipboard().copyAction('x', 'Custom label').label).toBe('Custom label')
+  })
+})

package/app/composables/useCopyToClipboard.ts

@@ -25,5 +25,21 @@ export function useCopyToClipboard() {
     }
   }
 
-  return { copy, isSupported }
+  /**
+   * A ready-made toast action that copies `text` (through {@link copy}, so it shows the
+   * same "Copied" / "Copy failed" feedback). Drop it into a toast's `actions` so any
+   * error/warning toast can offer a one-click "Copy details" — the message + context the
+   * user would otherwise have to retype into a bug report.
+   */
+  function copyAction(text: string, label?: string) {
+    return {
+      label: label ?? t('common.copyDetails'),
+      icon: 'i-lucide-clipboard',
+      onClick: () => {
+        void copy(text)
+      },
+    }
+  }
+
+  return { copy, copyAction, isSupported }
 }

package/app/stores/github.ts

@@ -11,6 +11,7 @@ import type {
   GitHubRepo,
   MergePullRequestInput,
   OpenPullRequestInput,
+  RepoTreeEntry,
   ResyncRequest,
 } from '~/types/domain'
 import { useSingleFlightProbe } from '~/composables/useSingleFlightProbe'
@@ -215,6 +216,26 @@ export const useGitHubStore = defineStore('github', () => {
     return api.listGitHubRepoTree(workspace.requireId(), repoGithubId, path)
   }
 
+  /** Full file listing per repo (recursive tree), cached by GitHub numeric id. */
+  const repoFiles = ref<Record<number, RepoTreeEntry[]>>({})
+
+  /**
+   * Load (and cache) EVERY file in a repo — the whole tree in one recursive read — so a
+   * picker can search files by path entirely client-side (no per-keystroke server call).
+   * Cached by repo id so re-opening the picker for the same repo is instant; force a
+   * refetch with `{ reload: true }`. Mirrors the branches cache.
+   */
+  async function loadRepoFiles(
+    repoGithubId: number,
+    opts: { reload?: boolean } = {},
+  ): Promise<RepoTreeEntry[]> {
+    const cached = repoFiles.value[repoGithubId]
+    if (cached && !opts.reload) return cached
+    const files = await api.listGitHubRepoFiles(workspace.requireId(), repoGithubId)
+    repoFiles.value = { ...repoFiles.value, [repoGithubId]: files }
+    return files
+  }
+
   /** The URL a workspace owner visits to install the App against this workspace. */
   function getInstallUrl(): Promise<string> {
     return api.getGitHubInstallUrl(workspace.requireId()).then((r) => r.url)
@@ -313,6 +334,7 @@ export const useGitHubStore = defineStore('github', () => {
     pulls.value = []
     issues.value = []
     branches.value = {}
+    repoFiles.value = {}
   }
 
   return {
@@ -347,6 +369,8 @@ export const useGitHubStore = defineStore('github', () => {
     searchAvailableRepos,
     setLinkedRepos,
     loadRepoTree,
+    repoFiles,
+    loadRepoFiles,
     loadBranches,
     getInstallUrl,
     loadInstallations,

package/app/stores/pipelines.ts

@@ -82,6 +82,8 @@ export const usePipelinesStore = defineStore('pipelines', () => {
   /** Organizational labels for the pipeline being assembled/edited. */
   const draftLabels = ref<string[]>([])
   const draftName = ref('New pipeline')
+  /** Prose description for the pipeline being assembled/edited (shown in the pickers). */
+  const draftDescription = ref('')
   /** The id of the pipeline being edited, or null when assembling a brand-new one. */
   const editingId = ref<string | null>(null)
 
@@ -322,6 +324,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftStepOptions.value = []
     draftLabels.value = []
     draftName.value = 'New pipeline'
+    draftDescription.value = ''
     editingId.value = null
   }
 
@@ -340,6 +343,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftStepOptions.value = pipeline.agentKinds.map((_, i) => pipeline.stepOptions?.[i] ?? null)
     draftLabels.value = [...(pipeline.labels ?? [])]
     draftName.value = pipeline.name
+    draftDescription.value = pipeline.description ?? ''
     editingId.value = pipeline.id
   }
 
@@ -347,6 +351,10 @@ export const usePipelinesStore = defineStore('pipelines', () => {
   function draftPayload() {
     return {
       name: draftName.value.trim() || 'Untitled pipeline',
+      // ALWAYS send description (like stepOptions) so an update can CLEAR it — an omitted field
+      // reads as "keep existing", so toggling the last of the text away must send the empty string.
+      // The backend trims + drops a blank one, so this is a no-op on create / an empty description.
+      description: draftDescription.value.trim(),
       agentKinds: [...draft.value],
       // Only send gates when at least one step is gated.
       ...(draftGates.value.some(Boolean) ? { gates: [...draftGates.value] } : {}),
@@ -452,6 +460,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftStepOptions,
     draftLabels,
     draftName,
+    draftDescription,
     editingId,
     units,
     hydrate,