@cat-factory/app 0.138.1 → 0.140.0

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/composables/useResultView.ts

@@ -13,23 +13,20 @@
  * A synchronous window (one that reads its data straight off the execution step, like the
  * test report) simply omits `onOpen`.
  *
- * `onClose` runs on EVERY close path — the X button, backdrop click, and the Escape key
- * handled here — BEFORE the view is torn down, so a window with unsaved draft input (the
- * review windows) can flush it in one place instead of every caller having to remember to.
- * It runs synchronously; if it kicks off async work it must capture whatever it needs first,
- * because `blockId`/the derived state go null the moment the view closes.
+ * `onClose` runs on EVERY close path — the X button, backdrop click, and the Escape key —
+ * BEFORE the view is torn down, so a window with unsaved draft input (the review windows) can
+ * flush it in one place instead of every caller having to remember to. It runs synchronously;
+ * if it kicks off async work it must capture whatever it needs first, because `blockId`/the
+ * derived state go null the moment the view closes.
  *
- * `manageEscape` (default `true`) owns the global Escape-to-close listener. A window that
- * renders through `ResultWindowShell` (slice 5 of the modular-vue adoption) passes `false`:
- * the shell's `useModalBehavior` owns Escape via the shared overlay stack (so the top
- * overlay closes first, and focus/scroll are managed too), and a second listener here would
- * double-fire `close`. Un-converted windows keep the default so they still close on Escape.
- * Remove this option once every result window is on the shell (the listener moves out
- * entirely).
+ * Escape-to-close is NOT owned here: every result window renders through `ResultWindowShell`
+ * (slice 5 of the modular-vue adoption), whose `useModalBehavior` owns Escape via the shared
+ * overlay stack (top overlay closes first, focus/scroll managed too). A listener here would
+ * double-fire `close`, so it was removed once the last window converted onto the shell.
  */
 export function useResultView(
   viewId: string,
-  opts?: { onOpen?: (blockId: string) => void; onClose?: () => void; manageEscape?: boolean },
+  opts?: { onOpen?: (blockId: string) => void; onClose?: () => void },
 ) {
   const ui = useUiStore()
 
@@ -47,14 +44,6 @@ export function useResultView(
     ui.closeResultView()
   }
 
-  function onKey(e: KeyboardEvent) {
-    if (e.key === 'Escape' && open.value) close()
-  }
-  if (opts?.manageEscape !== false) {
-    onMounted(() => window.addEventListener('keydown', onKey))
-    onBeforeUnmount(() => window.removeEventListener('keydown', onKey))
-  }
-
   // The load-on-open contract: fire immediately on mount and on any later block switch.
   if (opts?.onOpen) {
     watch(

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,

package/app/utils/pipeline.ts

@@ -1,5 +1,29 @@
 import { frameAllowsVisualPipeline, pipelineHasVisualStep } from '@cat-factory/contracts'
-import type { Block, Pipeline } from '~/types/domain'
+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 }))
+}
 
 // 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

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.",
@@ -3892,6 +3911,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.",

package/i18n/locales/es.json

@@ -49,6 +49,7 @@
       "reconfigureHint": "Puedes volver a configurarlo más tarde."
     },
     "copied": "Copiado al portapapeles",
+    "copyDetails": "Copiar detalles",
     "reveal": "Mostrar",
     "hide": "Ocultar",
     "disconnect": "Desconectar",
@@ -3202,6 +3203,17 @@
       "emptySearchable": "Busca por título o elige un documento importado.",
       "emptyRefOnly": "Pega la URL o el ID de una página para adjuntarla."
     },
+    "repoPicker": {
+      "searchRepoPlaceholder": "Buscar repositorios…",
+      "clearRepo": "Quitar repositorio",
+      "searchTab": "Buscar archivos",
+      "browseTab": "Explorar",
+      "searchFilesPlaceholder": "Buscar archivos por ruta…",
+      "searchFilesHint": "Escribe para buscar archivos en este repositorio.",
+      "noFileMatches": "No hay archivos coincidentes.",
+      "filesFailed": "No se pudieron cargar los archivos: {error}",
+      "moreFiles": "Mostrando las primeras {count} coincidencias; refina tu búsqueda para acotarla."
+    },
     "import": {
       "title": "Importar desde una fuente de documentos",
       "connectFirst": "Conecta primero una fuente de documentos.",
@@ -3350,6 +3362,13 @@
       "proceed": "Continuar de todos modos",
       "stopReset": "Detener y reiniciar la tarea"
     },
+    "preview": {
+      "stepCount": "{count} paso | {count} pasos",
+      "gated": "Aprobación humana después de este paso"
+    },
+    "picker": {
+      "noneHint": "Sin pipeline predeterminado. Eliges uno al ejecutar la tarea."
+    },
     "builder": {
       "title": "Constructor de pipelines",
       "agentPalette": "Paleta de agentes",
@@ -3358,6 +3377,7 @@
       "configureModels": "Configurar modelos",
       "configureModelsTooltip": "Gestionar los preajustes de modelos (qué modelo ejecuta cada agente)",
       "namePlaceholder": "Nombre del pipeline",
+      "descriptionPlaceholder": "Descripción (se muestra al elegir este pipeline)",
       "labelPlaceholder": "+ etiqueta",
       "gatingNeedsEstimator": "Un paso con compuerta necesita un Task Estimator antes. Añade uno o el pipeline no se guardará.",
       "emptyDraft": "Haz clic en los agentes de la izquierda para montar un pipeline lineal.",