@cat-factory/app 0.163.0 → 0.165.0

package/app/components/tasks/ContextIssuePicker.logic.spec.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest'
+import { buildSourceChoices, reconcileSource } from './ContextIssuePicker.logic'
+import type { TaskSourceState } from '~/types/domain'
+
+/**
+ * The pure source-selection behind `<ContextIssuePicker>`. Pins what the always-visible
+ * selector promises: the tracker in use is named even when it is the only one, a tracker
+ * the workspace hasn't got yet is offered as something to ADD (worded for its actual
+ * state), and the selection stays valid as the offered set changes underneath it.
+ */
+const state = (source: string, { available = true, enabled = true } = {}): TaskSourceState =>
+  ({
+    source,
+    label: source.toUpperCase(),
+    icon: `i-lucide-${source}`,
+    available,
+    enabled,
+    credentialFields: [],
+    refLabel: '',
+    refPlaceholder: '',
+  }) as unknown as TaskSourceState
+
+describe('buildSourceChoices', () => {
+  it('lists a single offered tracker, marked active (the selector is never hidden)', () => {
+    const groups = buildSourceChoices([state('github')], 'github')
+    expect(groups).toEqual([
+      [
+        {
+          action: 'select',
+          source: 'github',
+          label: 'GITHUB',
+          icon: 'i-lucide-github',
+          active: true,
+        },
+      ],
+    ])
+  })
+
+  it('marks only the selected tracker active', () => {
+    const [offered] = buildSourceChoices([state('github'), state('jira')], 'jira')
+    expect(offered!.map((c) => [c.source, 'active' in c && c.active])).toEqual([
+      ['github', false],
+      ['jira', true],
+    ])
+  })
+
+  it('offers an unavailable tracker as `connect` and an available-but-off one as `enable`', () => {
+    const [, addable] = buildSourceChoices(
+      [state('github'), state('jira', { available: false }), state('linear', { enabled: false })],
+      'github',
+    )
+    expect(addable).toEqual([
+      { action: 'connect', source: 'jira', label: 'JIRA', icon: 'i-lucide-jira' },
+      { action: 'enable', source: 'linear', label: 'LINEAR', icon: 'i-lucide-linear' },
+    ])
+  })
+
+  it('drops empty groups so the menu renders no stray separator', () => {
+    expect(buildSourceChoices([state('github')], 'github')).toHaveLength(1)
+    expect(buildSourceChoices([state('jira', { available: false })], undefined)).toHaveLength(1)
+    expect(buildSourceChoices([], undefined)).toEqual([])
+  })
+})
+
+describe('reconcileSource', () => {
+  it('selects the tracker the user just went off to connect, once it is offered', () => {
+    expect(reconcileSource(['github', 'jira'], 'github', 'jira')).toBe('jira')
+  })
+
+  it('keeps the current selection while the connect is still pending', () => {
+    expect(reconcileSource(['github'], 'github', 'jira')).toBe('github')
+  })
+
+  it('keeps a still-offered selection', () => {
+    expect(reconcileSource(['github', 'jira'], 'jira', null)).toBe('jira')
+  })
+
+  it('falls back to the first offered tracker when the selection stopped being offered', () => {
+    expect(reconcileSource(['github'], 'jira', null)).toBe('github')
+  })
+
+  it('selects the first offered tracker when nothing is selected yet', () => {
+    expect(reconcileSource(['github'], undefined, null)).toBe('github')
+  })
+
+  it('resolves to nothing when the workspace offers no tracker at all', () => {
+    expect(reconcileSource([], 'jira', 'jira')).toBeUndefined()
+  })
+})

package/app/components/tasks/ContextIssuePicker.logic.ts

@@ -0,0 +1,74 @@
+import type { TaskSourceKind, TaskSourceState } from '~/types/domain'
+
+/**
+ * Pure source-selection logic for `<ContextIssuePicker>`: which tracker the picker is
+ * searching, and what the source menu offers. Kept out of the component so both the
+ * template's `computed`s and the unit spec call the same code.
+ *
+ * The menu is deliberately two-tier — pick an already-offered tracker, or go and add
+ * one — because "attach a context issue" is where a user first discovers a tracker is
+ * missing, and sending them to the Integrations hub loses their in-progress task.
+ */
+
+/** One row of the picker's source menu. */
+export type SourceChoice =
+  /** An offered tracker the picker can search right now. */
+  | { action: 'select'; source: TaskSourceKind; label: string; icon: string; active: boolean }
+  /**
+   * A configured tracker that is not offered yet, so it can be added from here. `connect`
+   * has no credential/App behind it; `enable` is connected but toggled off for the
+   * workspace. Both open the same connect modal, which serves either case — only the
+   * wording differs, so the user isn't told to "connect" something already connected.
+   */
+  | { action: 'connect' | 'enable'; source: TaskSourceKind; label: string; icon: string }
+
+/**
+ * The picker's source menu, as non-empty groups (the offered trackers, then the ones the
+ * user could add). Empty groups are dropped so the menu never renders a stray separator.
+ */
+export function buildSourceChoices(
+  sources: TaskSourceState[],
+  selected: TaskSourceKind | undefined,
+): SourceChoice[][] {
+  const offered: SourceChoice[] = []
+  const addable: SourceChoice[] = []
+  for (const s of sources) {
+    if (s.available && s.enabled) {
+      offered.push({
+        action: 'select',
+        source: s.source,
+        label: s.label,
+        icon: s.icon,
+        active: s.source === selected,
+      })
+    } else {
+      addable.push({
+        action: s.available ? 'enable' : 'connect',
+        source: s.source,
+        label: s.label,
+        icon: s.icon,
+      })
+    }
+  }
+  return [offered, addable].filter((group) => group.length > 0)
+}
+
+/**
+ * The source the picker should hold once the offered set changes — after a connect, a
+ * disconnect, or the per-workspace toggle flipping elsewhere.
+ *
+ * `awaiting` is the tracker the user just left to connect: the moment it becomes offered
+ * it wins, so they land back on the source they went to add rather than on whatever was
+ * selected before. Otherwise a still-offered selection is kept, and a selection that
+ * stopped being offered falls back to the first one (searching a tracker the workspace no
+ * longer offers only yields errors).
+ */
+export function reconcileSource(
+  offered: TaskSourceKind[],
+  selected: TaskSourceKind | undefined,
+  awaiting: TaskSourceKind | null,
+): TaskSourceKind | undefined {
+  if (awaiting && offered.includes(awaiting)) return awaiting
+  if (selected && offered.includes(selected)) return selected
+  return offered[0]
+}

package/app/components/tasks/ContextIssuePicker.vue

@@ -6,8 +6,15 @@
 // It only *stages* a choice: the caller collects PendingContext items and links
 // them once the block exists (see useContextLinking). A search hit / pasted ref
 // carries `needsImport: true` so it's fetched + persisted before linking.
+//
+// The tracker being searched is ALWAYS on screen (even when the workspace offers
+// exactly one), and its menu doubles as the "add a tracker" affordance: attaching a
+// context issue is where a missing integration is discovered, and the connect modal
+// opens over the caller's form rather than navigating away from it.
+import type { DropdownMenuItem } from '@nuxt/ui'
 import type { SourceTask, TaskSearchResult, TaskSourceKind } from '~/types/domain'
 import EmptyState from '~/components/common/EmptyState.vue'
+import { buildSourceChoices, reconcileSource } from '~/components/tasks/ContextIssuePicker.logic'
 
 const props = defineProps<{
   /** contextKeys already staged by the caller, so they're filtered out / not re-offered. */
@@ -23,13 +30,6 @@ const props = defineProps<{
    * `v-model:source`); omitted, the picker manages it internally (the add-task case).
    */
   source?: TaskSourceKind
-  /**
-   * Always render the source selector, even with a single offered tracker — so the
-   * user can see *which* tracker is being searched (the "create task from issue"
-   * surface, where the source is otherwise invisible). Off by default: the inline
-   * add-task picker stays compact and only shows a selector when there's a choice.
-   */
-  alwaysShowSource?: boolean
 }>()
 const emit = defineEmits<{
   pick: [item: PendingContext]
@@ -38,12 +38,14 @@ const emit = defineEmits<{
 
 const { t } = useI18n()
 const tasks = useTasksStore()
+const ui = useUiStore()
 
 const chosen = computed(() => new Set(props.chosenKeys ?? []))
 
 // Source: default to the first offered tracker. Controlled when the parent passes
-// `source` (write-through to `update:source`), else internal. A selector appears when
-// more than one source is offered, or whenever the parent asks (`alwaysShowSource`).
+// `source` (write-through to `update:source`), else internal. The selector is always
+// rendered, single tracker or not — which tracker is being searched decides what a
+// pasted key resolves to, so it must never be invisible.
 const internalSource = ref<TaskSourceKind | undefined>(tasks.offeredSources[0]?.source)
 const source = computed<TaskSourceKind | undefined>({
   get: () => props.source ?? internalSource.value,
@@ -52,13 +54,49 @@ const source = computed<TaskSourceKind | undefined>({
     if (v) emit('update:source', v)
   },
 })
-const sourceItems = computed(() =>
-  tasks.offeredSources.map((s) => ({ label: s.label, value: s.source })),
+const descriptor = computed(() => (source.value ? tasks.descriptorFor(source.value) : undefined))
+
+// The tracker the user left to connect, so it becomes the selection the moment it turns
+// up offered (the connect modal re-probes on success). Also the reconcile trigger for a
+// source that stops being offered — disconnected, or toggled off in settings.
+const awaitingConnect = ref<TaskSourceKind | null>(null)
+function addSource(s: TaskSourceKind) {
+  awaitingConnect.value = s
+  ui.openTaskConnect(s)
+}
+watch(
+  () => tasks.offeredSources.map((s) => s.source),
+  (offered) => {
+    const next = reconcileSource(offered, source.value, awaitingConnect.value)
+    if (next && next === awaitingConnect.value) awaitingConnect.value = null
+    if (next !== source.value && next) source.value = next
+  },
 )
-const showSourceSelect = computed(
-  () => sourceItems.value.length > 1 || (props.alwaysShowSource && sourceItems.value.length > 0),
+
+// Two-tier menu: pick an offered tracker, or add one that isn't offered yet.
+const sourceMenu = computed<DropdownMenuItem[][]>(() =>
+  buildSourceChoices(tasks.sources, source.value).map((group) =>
+    group.map((choice) =>
+      choice.action === 'select'
+        ? {
+            label: choice.label,
+            icon: choice.icon,
+            trailingIcon: choice.active ? 'i-lucide-check' : undefined,
+            onSelect: () => {
+              source.value = choice.source
+            },
+          }
+        : {
+            label:
+              choice.action === 'enable'
+                ? t('tasks.picker.enableSource', { label: choice.label })
+                : t('tasks.picker.connectSource', { label: choice.label }),
+            icon: 'i-lucide-plug',
+            onSelect: () => addSource(choice.source),
+          },
+    ),
+  ),
 )
-const descriptor = computed(() => (source.value ? tasks.descriptorFor(source.value) : undefined))
 const searchable = computed(() => descriptor.value?.searchable ?? false)
 
 const query = ref('')
@@ -222,13 +260,25 @@ onMounted(() => {
 
 <template>
   <div class="space-y-2 rounded-lg border border-slate-800 bg-slate-900/40 p-2">
-    <USelect
-      v-if="showSourceSelect"
-      v-model="source"
-      :items="sourceItems"
-      size="xs"
-      class="w-full"
-    />
+    <!-- Which tracker is being searched, always visible, plus the trackers the user
+         could add from here (each opens the connect modal over the caller's form). -->
+    <div class="flex items-center gap-1.5">
+      <span class="shrink-0 text-[11px] font-semibold uppercase tracking-wide text-slate-500">
+        {{ t('tasks.picker.sourceLabel') }}
+      </span>
+      <UDropdownMenu :items="sourceMenu" :content="{ side: 'bottom', align: 'start' }">
+        <UButton
+          color="neutral"
+          variant="soft"
+          size="xs"
+          :icon="icon"
+          trailing-icon="i-lucide-chevron-down"
+          class="max-w-full"
+        >
+          <span class="truncate">{{ descriptor?.label ?? t('tasks.picker.noSource') }}</span>
+        </UButton>
+      </UDropdownMenu>
+    </div>
 
     <UInput
       v-model="query"

package/app/components/tasks/TaskImportModal.vue

@@ -27,7 +27,7 @@ const back = useIntegrationBack(open)
 
 // The tracker being browsed. Owned here (not the picker) so the epic action and the
 // ref-input placeholder share the same selected source; passed to the picker via
-// `v-model:source` with `always-show-source` so it's always visible + selectable.
+// `v-model:source`, whose selector always shows (and can add) the tracker in use.
 const source = ref<TaskSourceKind | undefined>(undefined)
 const ref_ = ref('')
 const importing = ref(false)
@@ -162,13 +162,11 @@ async function doSpawnEpic() {
              uses for context issues: search by title, pick an already-imported one,
              or paste a URL/key — choosing one opens the prefilled add-task form. The
              search is scoped to the chosen container's repo (so a GitHub search stays
-             in that service's repo and a pasted URL / bare number resolves there), and
-             the source selector is always shown so it's clear which tracker is in use. -->
+             in that service's repo and a pasted URL / bare number resolves there). -->
         <UFormField :label="t('tasks.import.searchIssues')">
           <ContextIssuePicker
             v-model:source="source"
             :scope-block-id="containerId"
-            always-show-source
             @pick="createFromPick"
           />
         </UFormField>

package/app/utils/pipeline.spec.ts

@@ -1,13 +1,53 @@
 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'
+import {
+  pipelineAllowedForManualStart,
+  pipelineDisplaySteps,
+  pipelineGateCount,
+} 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
 }
 
+// The data behind every picker's preview pane: the ordered steps a run will actually execute.
+describe('pipelineDisplaySteps', () => {
+  it('keeps the authored order and flags the gated steps', () => {
+    const p = pipeline({
+      agentKinds: ['task-estimator', 'coder', 'reviewer'],
+      gates: [false, true, false],
+    })
+    expect(pipelineDisplaySteps(p)).toEqual([
+      { kind: 'task-estimator', gated: false },
+      { kind: 'coder', gated: true },
+      { kind: 'reviewer', gated: false },
+    ])
+  })
+
+  it('drops steps disabled by default — they never run, so listing them would misdescribe it', () => {
+    // The short `enabled` array also pins "no entry ⇒ enabled": `tester` has none and stays.
+    const p = pipeline({ agentKinds: ['architect', 'coder', 'tester'], enabled: [false, true] })
+    expect(pipelineDisplaySteps(p).map((s) => s.kind)).toEqual(['coder', 'tester'])
+  })
+})
+
+describe('pipelineGateCount', () => {
+  it('counts only the gates that a run can actually stop at', () => {
+    expect(pipelineGateCount(pipeline({ agentKinds: ['coder'] }))).toBe(0)
+    expect(
+      pipelineGateCount(pipeline({ agentKinds: ['coder', 'merger'], gates: [true, true] })),
+    ).toBe(2)
+    // A gate declared on a disabled step gates nothing: the step is skipped at run.
+    expect(
+      pipelineGateCount(
+        pipeline({ agentKinds: ['coder', 'merger'], gates: [true, true], enabled: [true, false] }),
+      ),
+    ).toBe(1)
+  })
+})
+
 describe('pipelineAllowedForTaskType', () => {
   it('a document task offers ONLY document-purpose pipelines', () => {
     expect(pipelineAllowedForTaskType(pipeline({ purpose: 'document' }), 'document')).toBe(true)

package/app/utils/pipeline.ts

@@ -29,6 +29,15 @@ export function pipelineDisplaySteps(pipeline: Pipeline): PipelineDisplayStep[]
     .map(({ kind, gated }) => ({ kind, gated }))
 }
 
+/**
+ * How many times a run of `pipeline` will stop for a human. Counted off the DISPLAYED steps, not
+ * `pipeline.gates`, because a gate declared on a step that is disabled by default gates nothing —
+ * that step never runs, so promising a stop there would misstate what the pipeline does.
+ */
+export function pipelineGateCount(pipeline: Pipeline): number {
+  return pipelineDisplaySteps(pipeline).filter((s) => s.gated).length
+}
+
 // 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 }

package/i18n/locales/de.json

@@ -3245,7 +3245,11 @@
       "attachByReference": "{ref} per Referenz anhängen",
       "noMatches": "Keine passenden Issues.",
       "emptySearchable": "Nach Titel suchen oder ein importiertes Issue auswählen.",
-      "emptyRefOnly": "Fügen Sie eine Issue-URL oder einen -Schlüssel ein, um es anzuhängen."
+      "emptyRefOnly": "Fügen Sie eine Issue-URL oder einen -Schlüssel ein, um es anzuhängen.",
+      "sourceLabel": "Quelle",
+      "noSource": "Quelle wählen",
+      "connectSource": "{label} verbinden",
+      "enableSource": "{label} aktivieren"
     },
     "contextIssues": {
       "title": "Kontext-Issues",
@@ -3358,10 +3362,12 @@
     },
     "preview": {
       "stepCount": "{count} Schritt | {count} Schritte",
+      "gateCount": "{count} Freigabe | {count} Freigaben",
       "gated": "Manuelle Freigabe nach diesem Schritt"
     },
     "picker": {
-      "noneHint": "Keine Standard-Pipeline. Du wählst beim Ausführen der Aufgabe eine aus."
+      "noneHint": "Keine Standard-Pipeline. Du wählst beim Ausführen der Aufgabe eine aus.",
+      "hoverHint": "Fahre über eine Pipeline, um die Schritte zu sehen, die sie ausführt."
     },
     "builder": {
       "title": "Pipeline-Builder",
@@ -3586,6 +3592,11 @@
     "recommendationRequested": "Empfehlung angefordert — prüfen Sie den Vorschlag unten.",
     "recommendedDefault": "Empfohlene Vorgabe: behalten, bearbeiten oder die Feststellung verwerfen.",
     "needsYourInput": "Benötigt Ihre Eingabe",
+    "group": {
+      "action": "Benötigt Ihre Reaktion",
+      "waiting": "Warten auf Vorschläge",
+      "settled": "Erledigt"
+    },
     "mode": {
       "answer": "Beantworten",
       "dismiss": "Verwerfen",

package/i18n/locales/en.json

@@ -3644,7 +3644,11 @@
       "attachByReference": "Attach {ref} by reference",
       "noMatches": "No matching issues.",
       "emptySearchable": "Search by title, or pick an imported issue.",
-      "emptyRefOnly": "Paste an issue URL or key to attach it."
+      "emptyRefOnly": "Paste an issue URL or key to attach it.",
+      "sourceLabel": "Source",
+      "noSource": "Choose a source",
+      "connectSource": "Connect {label}",
+      "enableSource": "Enable {label}"
     },
     "contextIssues": {
       "title": "Context issues",
@@ -3763,10 +3767,12 @@
     },
     "preview": {
       "stepCount": "{count} step | {count} steps",
+      "gateCount": "{count} approval gate | {count} approval gates",
       "gated": "Human approval gate after this step"
     },
     "picker": {
-      "noneHint": "No default pipeline. You choose one when you run the task."
+      "noneHint": "No default pipeline. You choose one when you run the task.",
+      "hoverHint": "Hover a pipeline to see the steps it runs."
     },
     "builder": {
       "title": "Pipeline builder",
@@ -4139,6 +4145,11 @@
     "recommendationRequested": "Recommendation requested — review the suggestion below.",
     "recommendedDefault": "Recommended default — keep it, edit it, or dismiss the finding.",
     "needsYourInput": "Needs your input",
+    "group": {
+      "action": "Needs your reaction",
+      "waiting": "Waiting on suggestions",
+      "settled": "Handled"
+    },
     "mode": {
       "answer": "Answer",
       "dismiss": "Dismiss",

package/i18n/locales/es.json

@@ -3539,7 +3539,11 @@
       "attachByReference": "Adjuntar {ref} por referencia",
       "noMatches": "No hay incidencias coincidentes.",
       "emptySearchable": "Busca por título o elige una incidencia importada.",
-      "emptyRefOnly": "Pega la URL o clave de una incidencia para adjuntarla."
+      "emptyRefOnly": "Pega la URL o clave de una incidencia para adjuntarla.",
+      "sourceLabel": "Fuente",
+      "noSource": "Elige una fuente",
+      "connectSource": "Conectar {label}",
+      "enableSource": "Habilitar {label}"
     },
     "contextIssues": {
       "title": "Incidencias de contexto",
@@ -3652,10 +3656,12 @@
     },
     "preview": {
       "stepCount": "{count} paso | {count} pasos",
+      "gateCount": "{count} aprobación | {count} aprobaciones",
       "gated": "Aprobación humana después de este paso"
     },
     "picker": {
-      "noneHint": "Sin pipeline predeterminado. Eliges uno al ejecutar la tarea."
+      "noneHint": "Sin pipeline predeterminado. Eliges uno al ejecutar la tarea.",
+      "hoverHint": "Pasa el cursor por una pipeline para ver los pasos que ejecuta."
     },
     "builder": {
       "title": "Constructor de pipelines",
@@ -3990,6 +3996,11 @@
     "recommendationRequested": "Recomendación solicitada — revisa la sugerencia más abajo.",
     "recommendedDefault": "Valor recomendado por defecto: consérvalo, edítalo o descarta el hallazgo.",
     "needsYourInput": "Necesita tu intervención",
+    "group": {
+      "action": "Necesita tu reacción",
+      "waiting": "Esperando sugerencias",
+      "settled": "Gestionados"
+    },
     "mode": {
       "answer": "Responder",
       "dismiss": "Descartar",

package/i18n/locales/fr.json

@@ -3539,7 +3539,11 @@
       "attachByReference": "Joindre {ref} par référence",
       "noMatches": "Aucun ticket correspondant.",
       "emptySearchable": "Recherchez par titre ou choisissez un ticket importé.",
-      "emptyRefOnly": "Collez l'URL ou la clé d'un ticket pour le joindre."
+      "emptyRefOnly": "Collez l'URL ou la clé d'un ticket pour le joindre.",
+      "sourceLabel": "Source",
+      "noSource": "Choisir une source",
+      "connectSource": "Connecter {label}",
+      "enableSource": "Activer {label}"
     },
     "contextIssues": {
       "title": "Tickets de contexte",
@@ -3652,10 +3656,12 @@
     },
     "preview": {
       "stepCount": "{count} étape | {count} étapes",
+      "gateCount": "{count} validation | {count} validations",
       "gated": "Validation humaine après cette étape"
     },
     "picker": {
-      "noneHint": "Aucun pipeline par défaut. Vous en choisissez un au lancement de la tâche."
+      "noneHint": "Aucun pipeline par défaut. Vous en choisissez un au lancement de la tâche.",
+      "hoverHint": "Survolez un pipeline pour voir les étapes qu'il exécute."
     },
     "builder": {
       "title": "Constructeur de pipelines",
@@ -3990,6 +3996,11 @@
     "recommendationRequested": "Recommandation demandée — consultez la suggestion ci-dessous.",
     "recommendedDefault": "Valeur recommandée par défaut : conservez-la, modifiez-la ou rejetez la constatation.",
     "needsYourInput": "Nécessite votre intervention",
+    "group": {
+      "action": "Nécessite votre réaction",
+      "waiting": "En attente de suggestions",
+      "settled": "Traitées"
+    },
     "mode": {
       "answer": "Répondre",
       "dismiss": "Ignorer",

package/i18n/locales/he.json

@@ -3550,7 +3550,11 @@
       "attachByReference": "צרף {ref} לפי הפניה",
       "noMatches": "אין ניושנים תואמים.",
       "emptySearchable": "חפש לפי כותרת, או בחר ניושן מיובא.",
-      "emptyRefOnly": "הדבק URL או מפתח של ניושן כדי לצרף אותו."
+      "emptyRefOnly": "הדבק URL או מפתח של ניושן כדי לצרף אותו.",
+      "sourceLabel": "מקור",
+      "noSource": "בחר מקור",
+      "connectSource": "חבר {label}",
+      "enableSource": "הפעל {label}"
     },
     "contextIssues": {
       "title": "ניושני הקשר",
@@ -3663,10 +3667,12 @@
     },
     "preview": {
       "stepCount": "שלב {count} | {count} שלבים",
+      "gateCount": "אישור {count} | {count} אישורים",
       "gated": "אישור אנושי אחרי שלב זה"
     },
     "picker": {
-      "noneHint": "אין צינור ברירת מחדל. בוחרים אחד כשמריצים את המשימה."
+      "noneHint": "אין צינור ברירת מחדל. בוחרים אחד כשמריצים את המשימה.",
+      "hoverHint": "העבירו את העכבר מעל צינור כדי לראות את השלבים שהוא מריץ."
     },
     "builder": {
       "title": "בונה הצינור",
@@ -4001,6 +4007,11 @@
     "recommendationRequested": "התבקשה המלצה — סקור את ההצעה שלהלן.",
     "recommendedDefault": "ברירת מחדל מומלצת: השאר אותה, ערוך אותה או דחה את הממצא.",
     "needsYourInput": "דורש את הקלט שלך",
+    "group": {
+      "action": "דורש את תגובתך",
+      "waiting": "ממתין להצעות",
+      "settled": "טופלו"
+    },
     "mode": {
       "answer": "ענה",
       "dismiss": "דחה",

package/i18n/locales/it.json

@@ -3245,7 +3245,11 @@
       "attachByReference": "Allega {ref} per riferimento",
       "noMatches": "Nessuna issue corrispondente.",
       "emptySearchable": "Cerca per titolo, oppure scegli una issue importata.",
-      "emptyRefOnly": "Incolla l'URL o la chiave di una issue per allegarla."
+      "emptyRefOnly": "Incolla l'URL o la chiave di una issue per allegarla.",
+      "sourceLabel": "Fonte",
+      "noSource": "Scegli una fonte",
+      "connectSource": "Collega {label}",
+      "enableSource": "Abilita {label}"
     },
     "contextIssues": {
       "title": "Issue di contesto",
@@ -3358,10 +3362,12 @@
     },
     "preview": {
       "stepCount": "{count} step | {count} step",
+      "gateCount": "{count} approvazione | {count} approvazioni",
       "gated": "Approvazione umana dopo questo step"
     },
     "picker": {
-      "noneHint": "Nessuna pipeline predefinita. Ne scegli una quando esegui l'attivita."
+      "noneHint": "Nessuna pipeline predefinita. Ne scegli una quando esegui l'attivita.",
+      "hoverHint": "Passa il mouse su una pipeline per vedere gli step che esegue."
     },
     "builder": {
       "title": "Costruttore di pipeline",
@@ -3586,6 +3592,11 @@
     "recommendationRequested": "Raccomandazione richiesta — rivedi il suggerimento qui sotto.",
     "recommendedDefault": "Valore predefinito consigliato: mantienilo, modificalo o ignora il rilievo.",
     "needsYourInput": "Richiede il tuo intervento",
+    "group": {
+      "action": "Richiede la tua reazione",
+      "waiting": "In attesa di suggerimenti",
+      "settled": "Gestiti"
+    },
     "mode": {
       "answer": "Rispondi",
       "dismiss": "Ignora",