@cat-factory/app 0.139.0 → 0.141.0

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

@@ -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,7 +81,16 @@ 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('')
   /** The id of the pipeline being edited, or null when assembling a brand-new one. */
   const editingId = ref<string | null>(null)
 
@@ -321,7 +330,9 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftTesterQuality.value = []
     draftStepOptions.value = []
     draftLabels.value = []
+    draftPurpose.value = null
     draftName.value = 'New pipeline'
+    draftDescription.value = ''
     editingId.value = null
   }
 
@@ -339,7 +350,9 @@ 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
   }
 
@@ -347,6 +360,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] } : {}),
@@ -381,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 } : {}),
     }
   }
 
@@ -451,7 +472,9 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     draftTesterQuality,
     draftStepOptions,
     draftLabels,
+    draftPurpose,
     draftName,
+    draftDescription,
     editingId,
     units,
     hydrate,

package/app/types/domain.ts

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

package/app/utils/pipeline.spec.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest'
+import { pipelineAllowedForTaskType, purposeAllowsAgentCategory } from '@cat-factory/contracts'
+import type { Block, Pipeline } from '~/types/domain'
+import { pipelineAllowedForManualStart } from '~/utils/pipeline'
+
+// A minimal pipeline: only the fields the launch/task-type filters read matter here.
+function pipeline(over: Partial<Pipeline> = {}): Pipeline {
+  return { id: 'pl_x', name: 'X', agentKinds: ['coder'], ...over } as Pipeline
+}
+
+describe('pipelineAllowedForTaskType', () => {
+  it('a document task offers ONLY document-purpose pipelines', () => {
+    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)
+  })
+
+  it('every non-document task type is unrestricted (any purpose, and undefined type)', () => {
+    for (const type of ['feature', 'bug', 'spike', 'review', 'ralph', undefined] as const) {
+      expect(pipelineAllowedForTaskType(pipeline({ purpose: 'build' }), type)).toBe(true)
+      expect(pipelineAllowedForTaskType(pipeline({ purpose: 'document' }), type)).toBe(true)
+      expect(pipelineAllowedForTaskType(pipeline({ purpose: undefined }), type)).toBe(true)
+    }
+  })
+})
+
+describe('purposeAllowsAgentCategory (builder palette gate)', () => {
+  it('a build (or unclassified) pipeline may use every category', () => {
+    for (const purpose of ['build', null, undefined] as const) {
+      for (const cat of ['review', 'design', 'build', 'test', 'docs', 'gates'] as const) {
+        expect(purposeAllowsAgentCategory(purpose, cat)).toBe(true)
+      }
+    }
+  })
+
+  it('a non-build pipeline hides the Implementation (build) and Testing (test) categories', () => {
+    for (const purpose of ['document', 'review', 'research', 'planning'] as const) {
+      expect(purposeAllowsAgentCategory(purpose, 'build')).toBe(false)
+      expect(purposeAllowsAgentCategory(purpose, 'test')).toBe(false)
+      // Non-code categories stay visible.
+      expect(purposeAllowsAgentCategory(purpose, 'docs')).toBe(true)
+      expect(purposeAllowsAgentCategory(purpose, 'review')).toBe(true)
+      expect(purposeAllowsAgentCategory(purpose, 'gates')).toBe(true)
+    }
+  })
+})
+
+describe('pipelineAllowedForManualStart composes the task-type gate', () => {
+  const noFrame = undefined
+  const blocks: Block[] = []
+
+  it('drops a non-document pipeline for a document task, keeps it for others', () => {
+    const build = pipeline({ purpose: 'build' })
+    expect(pipelineAllowedForManualStart(build, noFrame, blocks, 'document')).toBe(false)
+    expect(pipelineAllowedForManualStart(build, noFrame, blocks, 'feature')).toBe(true)
+    // No task type supplied ⇒ no task-type restriction.
+    expect(pipelineAllowedForManualStart(build, noFrame, blocks)).toBe(true)
+  })
+
+  it('still excludes recurring-only pipelines regardless of task type', () => {
+    const recurring = pipeline({ purpose: 'document', availability: 'recurring' })
+    expect(pipelineAllowedForManualStart(recurring, noFrame, blocks, 'document')).toBe(false)
+  })
+})

package/app/utils/pipeline.ts

@@ -1,5 +1,37 @@
-import { frameAllowsVisualPipeline, pipelineHasVisualStep } from '@cat-factory/contracts'
-import type { Block, Pipeline } from '~/types/domain'
+import {
+  frameAllowsVisualPipeline,
+  pipelineAllowedForTaskType,
+  pipelineHasVisualStep,
+} from '@cat-factory/contracts'
+import type { AgentKind, Block, Pipeline } from '~/types/domain'
+
+/** One agent step of a pipeline as shown in a preview: its kind + whether it's a human-gated step. */
+export interface PipelineDisplayStep {
+  kind: AgentKind
+  /** A human approval gate pauses the run after this step (`gates[i]`). */
+  gated: boolean
+}
+
+/**
+ * The steps a pipeline preview should render: the ENABLED steps in order (a step disabled by
+ * default — `enabled[i] === false` — is skipped at run, so it would misrepresent the pipeline to
+ * list it), each flagged when it carries a human approval gate. Companions are included as their
+ * own chips, mirroring how the run timeline lists every step.
+ */
+export function pipelineDisplaySteps(pipeline: Pipeline): PipelineDisplayStep[] {
+  return pipeline.agentKinds
+    .map((kind, i) => ({
+      kind,
+      enabled: pipeline.enabled?.[i] !== false,
+      gated: pipeline.gates?.[i] === true,
+    }))
+    .filter((s) => s.enabled)
+    .map(({ kind, gated }) => ({ kind, gated }))
+}
+
+// Re-exported so a picker can import the task-type gate from the same module as the
+// launch/frame gates it composes with (the classifier itself lives in `@cat-factory/contracts`).
+export { pipelineAllowedForTaskType }
 
 // Surface counterpart to the backend's slice-4c run-start gate: a pipeline with a visual step
 // (`tester-ui` / `visual-confirmation`) may run only on a frame with a UI to exercise — a
@@ -29,14 +61,21 @@ export function pipelineAllowedForFrame(
 /**
  * Whether `pipeline` may be started as a MANUAL one-off task run (the board/inspector Run menus,
  * the add-task modal, the task run-settings default). Excludes `'recurring'`-only pipelines the
- * backend would refuse.
+ * backend would refuse, visual pipelines on a frame with no UI, and — when a `taskType` is given —
+ * pipelines whose `purpose` doesn't fit that task type (a `document` task offers only document
+ * pipelines). `taskType` omitted ⇒ no task-type restriction (an un-typed context shows all).
  */
 export function pipelineAllowedForManualStart(
   pipeline: Pipeline,
   frame: Block | undefined,
   blocks: readonly Block[],
+  taskType?: Block['taskType'],
 ): boolean {
-  return pipeline.availability !== 'recurring' && pipelineAllowedForFrame(pipeline, frame, blocks)
+  return (
+    pipeline.availability !== 'recurring' &&
+    pipelineAllowedForFrame(pipeline, frame, blocks) &&
+    pipelineAllowedForTaskType(pipeline, taskType)
+  )
 }
 
 /**

package/i18n/locales/de.json

@@ -2936,6 +2936,17 @@
       "emptySearchable": "Nach Titel suchen oder ein importiertes Dokument auswählen.",
       "emptyRefOnly": "Fügen Sie eine Seiten-URL oder -ID ein, um sie anzuhängen."
     },
+    "repoPicker": {
+      "searchRepoPlaceholder": "Repositorys suchen…",
+      "clearRepo": "Repository entfernen",
+      "searchTab": "Dateien suchen",
+      "browseTab": "Durchsuchen",
+      "searchFilesPlaceholder": "Dateien nach Pfad suchen…",
+      "searchFilesHint": "Tippen, um Dateien in diesem Repository zu suchen.",
+      "noFileMatches": "Keine passenden Dateien.",
+      "filesFailed": "Dateien konnten nicht geladen werden: {error}",
+      "moreFiles": "Es werden die ersten {count} Treffer angezeigt – grenzen Sie Ihre Suche ein."
+    },
     "import": {
       "title": "Aus einer Dokumentquelle importieren",
       "connectFirst": "Verbinden Sie zuerst eine Dokumentquelle.",
@@ -3084,6 +3095,13 @@
       "proceed": "Trotzdem fortfahren",
       "stopReset": "Aufgabe stoppen & zurücksetzen"
     },
+    "preview": {
+      "stepCount": "{count} Schritt | {count} Schritte",
+      "gated": "Manuelle Freigabe nach diesem Schritt"
+    },
+    "picker": {
+      "noneHint": "Keine Standard-Pipeline. Du wählst beim Ausführen der Aufgabe eine aus."
+    },
     "builder": {
       "title": "Pipeline-Builder",
       "agentPalette": "Agenten-Palette",
@@ -3092,6 +3110,7 @@
       "configureModels": "Modelle konfigurieren",
       "configureModelsTooltip": "Modell-Presets verwalten (auf welchem Modell jeder Agent läuft)",
       "namePlaceholder": "Pipeline-Name",
+      "descriptionPlaceholder": "Beschreibung (wird bei der Pipeline-Auswahl angezeigt)",
       "labelPlaceholder": "+ Label",
       "gatingNeedsEstimator": "Ein Gated-Schritt benötigt davor einen Task Estimator. Fügen Sie einen hinzu, sonst wird die Pipeline nicht gespeichert.",
       "emptyDraft": "Klicken Sie links auf Agenten, um eine lineare Pipeline zusammenzustellen.",
@@ -3123,6 +3142,15 @@
       "impactThreshold": "Auswirkung ≥",
       "strategy": "Strategie",
       "rounds": "Runden",
+      "purposeLabel": "Zweck",
+      "purposePlaceholder": "Zweck auswählen",
+      "purposeOption": {
+        "build": "Entwicklung",
+        "document": "Dokumentation",
+        "review": "Review",
+        "research": "Recherche",
+        "planning": "Planung"
+      },
       "strategyOption": {
         "specialist-panel": "Spezialisten-Panel",
         "debate": "Debatte",
@@ -3176,7 +3204,8 @@
       "skillPlaceholder": "Skill auswählen",
       "skillNoneAvailable": "Keine Skills verfügbar. Verknüpfe eine Skill-Quelle in den Kontoeinstellungen.",
       "skillMissing": "Dieser Skill ist nicht mehr im Katalog; wähle einen anderen.",
-      "skillNeedsPick": "Ein Skill-Schritt braucht einen ausgewählten Skill, bevor du speichern kannst."
+      "skillNeedsPick": "Ein Skill-Schritt braucht einen ausgewählten Skill, bevor du speichern kannst.",
+      "purposeStepsConflict": "Dieser Zweck schreibt keinen Code und führt keine Tests aus, doch die Pipeline enthält noch Implementierungs- oder Testschritte. Entfernen Sie diese oder setzen Sie den Zweck auf Entwicklung."
     },
     "progress": {
       "status": {
@@ -3892,6 +3921,7 @@
     "retry": "Erneut versuchen",
     "copy": "Kopieren",
     "copied": "In die Zwischenablage kopiert",
+    "copyDetails": "Details kopieren",
     "reveal": "Anzeigen",
     "hide": "Verbergen",
     "delete": "Löschen",

package/i18n/locales/en.json

@@ -30,6 +30,7 @@
     "retry": "Retry",
     "copy": "Copy",
     "copied": "Copied to clipboard",
+    "copyDetails": "Copy details",
     "reveal": "Reveal",
     "hide": "Hide",
     "delete": "Delete",
@@ -3298,6 +3299,17 @@
       "emptySearchable": "Search by title, or pick an imported document.",
       "emptyRefOnly": "Paste a page URL or ID to attach it."
     },
+    "repoPicker": {
+      "searchRepoPlaceholder": "Search repositories…",
+      "clearRepo": "Clear repository",
+      "searchTab": "Search files",
+      "browseTab": "Browse",
+      "searchFilesPlaceholder": "Search files by path…",
+      "searchFilesHint": "Type to search files in this repository.",
+      "noFileMatches": "No matching files.",
+      "filesFailed": "Couldn't load files: {error}",
+      "moreFiles": "Showing the first {count} matches — refine your search to narrow it down."
+    },
     "import": {
       "title": "Import from a document source",
       "connectFirst": "Connect a document source first.",
@@ -3449,6 +3461,13 @@
       "proceed": "Proceed anyway",
       "stopReset": "Stop & reset task"
     },
+    "preview": {
+      "stepCount": "{count} step | {count} steps",
+      "gated": "Human approval gate after this step"
+    },
+    "picker": {
+      "noneHint": "No default pipeline. You choose one when you run the task."
+    },
     "builder": {
       "title": "Pipeline builder",
       "agentPalette": "Agent palette",
@@ -3457,6 +3476,7 @@
       "configureModels": "Configure models",
       "configureModelsTooltip": "Manage model presets (which model each agent runs on)",
       "namePlaceholder": "Pipeline name",
+      "descriptionPlaceholder": "Description (shown when picking this pipeline)",
       "labelPlaceholder": "+ label",
       "gatingNeedsEstimator": "A gated step needs a Task Estimator before it. Add one or the pipeline won't save.",
       "emptyDraft": "Click agents on the left to assemble a linear pipeline.",
@@ -3488,6 +3508,15 @@
       "impactThreshold": "impact ≥",
       "strategy": "Strategy",
       "rounds": "Rounds",
+      "purposeLabel": "Purpose",
+      "purposePlaceholder": "Select a purpose",
+      "purposeOption": {
+        "build": "Build",
+        "document": "Documentation",
+        "review": "Review",
+        "research": "Research",
+        "planning": "Planning"
+      },
       "strategyOption": {
         "specialist-panel": "Specialist panel",
         "debate": "Debate",
@@ -3541,7 +3570,8 @@
       "skillPlaceholder": "Select a skill",
       "skillNoneAvailable": "No skills available. Link a skill source in account settings.",
       "skillMissing": "This skill is no longer in the catalog; pick another.",
-      "skillNeedsPick": "A Skill step needs a skill selected before you can save."
+      "skillNeedsPick": "A Skill step needs a skill selected before you can save.",
+      "purposeStepsConflict": "This purpose writes no code and runs no tests, but the pipeline still has implementation or testing steps. Remove them or switch the purpose to Build."
     },
     "progress": {
       "status": {