@cat-factory/app 0.87.4 → 0.88.0

package/app/components/settings/ServiceFragmentDefaultsPanel.vue

@@ -6,6 +6,7 @@
 // services — each owns its selection from creation. Persisted via the
 // serviceFragmentDefaults store (the backend replaces the whole list on each change).
 import { onMounted, ref } from 'vue'
+import { buildFragmentPickerGroups } from '~/utils/fragmentPicker'
 
 const { t } = useI18n()
 const fragments = useFragmentsStore()
@@ -24,17 +25,10 @@ const selected = computed(() =>
   defaults.fragmentIds.map((id) => fragments.getFragment(id) ?? { id, title: id, summary: '' }),
 )
 
-// Pool fragments not already in the default set, grouped by category.
+// Pool fragments not already in the default set, grouped into labelled per-category sections.
 const menu = computed(() => {
   const chosen = new Set(defaults.fragmentIds)
-  const groups = new Map<string, { label: string; onSelect: () => void }[]>()
-  for (const f of fragments.fragments) {
-    if (chosen.has(f.id)) continue
-    const items = groups.get(f.category) ?? []
-    items.push({ label: f.title, onSelect: () => add(f.id) })
-    groups.set(f.category, items)
-  }
-  return [...groups.values()]
+  return buildFragmentPickerGroups(fragments.fragments, (id) => chosen.has(id), add)
 })
 
 async function save(ids: string[]) {

package/app/composables/api/initiative.ts

@@ -3,12 +3,21 @@ import {
   cancelInitiativeContract,
   continueInitiativePlanningContract,
   createInitiativeContract,
+  dismissInitiativeFollowUpContract,
   getInitiativeByBlockContract,
   getInitiativeContract,
   listInitiativesContract,
   pauseInitiativeContract,
   proceedInitiativePlanningContract,
+  promoteInitiativeFollowUpContract,
   resumeInitiativeContract,
+  updateInitiativeItemContract,
+  updateInitiativePolicyContract,
+} from '@cat-factory/contracts'
+import type {
+  InitiativeExecutionPolicy,
+  PromoteInitiativeFollowUpInput,
+  UpdateInitiativeItemInput,
 } from '@cat-factory/contracts'
 import type { ApiContext } from './context'
 
@@ -66,5 +75,47 @@ export function initiativeApi({ send, ws }: ApiContext) {
 
     cancelInitiative: (workspaceId: string, blockId: string) =>
       send(cancelInitiativeContract, { pathPrefix: ws(workspaceId), pathParams: { blockId } }),
+
+    // Follow-up triage + item/policy editing (slice 4): keyed by initiative id.
+    promoteInitiativeFollowUp: (
+      workspaceId: string,
+      initiativeId: string,
+      followUpId: string,
+      body: PromoteInitiativeFollowUpInput,
+    ) =>
+      send(promoteInitiativeFollowUpContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { initiativeId, followUpId },
+        body,
+      }),
+
+    dismissInitiativeFollowUp: (workspaceId: string, initiativeId: string, followUpId: string) =>
+      send(dismissInitiativeFollowUpContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { initiativeId, followUpId },
+      }),
+
+    updateInitiativeItem: (
+      workspaceId: string,
+      initiativeId: string,
+      itemId: string,
+      body: UpdateInitiativeItemInput,
+    ) =>
+      send(updateInitiativeItemContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { initiativeId, itemId },
+        body,
+      }),
+
+    updateInitiativePolicy: (
+      workspaceId: string,
+      initiativeId: string,
+      body: InitiativeExecutionPolicy,
+    ) =>
+      send(updateInitiativePolicyContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { initiativeId },
+        body,
+      }),
   }
 }

package/app/stores/initiative.ts

@@ -1,6 +1,11 @@
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
-import type { Initiative } from '~/types/domain'
+import type {
+  Initiative,
+  InitiativeExecutionPolicy,
+  PromoteInitiativeFollowUpInput,
+  UpdateInitiativeItemInput,
+} from '~/types/domain'
 import { useWorkspaceStore } from '~/stores/workspace'
 import { useBoardStore } from '~/stores/board'
 
@@ -154,6 +159,77 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     }
   }
 
+  /** True while a curation action (promote/dismiss/edit item/edit policy) is in flight. */
+  const curating = ref(false)
+
+  async function curate<T>(fn: () => Promise<T>): Promise<T> {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    curating.value = true
+    try {
+      return await fn()
+    } finally {
+      curating.value = false
+    }
+  }
+
+  /** Promote an `open` harvested follow-up into a new pending tracker item. */
+  async function promoteFollowUp(
+    initiativeId: string,
+    followUpId: string,
+    input: PromoteInitiativeFollowUpInput,
+  ) {
+    return curate(async () => {
+      const updated = await api.promoteInitiativeFollowUp(
+        workspace.workspaceId!,
+        initiativeId,
+        followUpId,
+        input,
+      )
+      upsert(updated)
+      return updated
+    })
+  }
+
+  /** Dismiss a harvested follow-up. */
+  async function dismissFollowUp(initiativeId: string, followUpId: string) {
+    return curate(async () => {
+      const updated = await api.dismissInitiativeFollowUp(
+        workspace.workspaceId!,
+        initiativeId,
+        followUpId,
+      )
+      upsert(updated)
+      return updated
+    })
+  }
+
+  /** Edit one tracker item and/or drive its status (retry a blocked item / skip it). */
+  async function updateItem(
+    initiativeId: string,
+    itemId: string,
+    input: UpdateInitiativeItemInput,
+  ) {
+    return curate(async () => {
+      const updated = await api.updateInitiativeItem(
+        workspace.workspaceId!,
+        initiativeId,
+        itemId,
+        input,
+      )
+      upsert(updated)
+      return updated
+    })
+  }
+
+  /** Replace the execution policy (concurrency + pipeline rules). */
+  async function updatePolicy(initiativeId: string, policy: InitiativeExecutionPolicy) {
+    return curate(async () => {
+      const updated = await api.updateInitiativePolicy(workspace.workspaceId!, initiativeId, policy)
+      upsert(updated)
+      return updated
+    })
+  }
+
   function reset() {
     byBlock.value = {}
   }
@@ -165,6 +241,7 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     creating,
     resuming,
     controlling,
+    curating,
     forBlock,
     hydrate,
     upsert,
@@ -174,6 +251,10 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     continuePlanning,
     proceedPlanning,
     control,
+    promoteFollowUp,
+    dismissFollowUp,
+    updateItem,
+    updatePolicy,
     reset,
   }
 })

package/app/types/initiative.ts

@@ -15,4 +15,7 @@ export type {
   InitiativePipelineRule,
   InitiativeQa,
   InitiativeStatus,
+  PromoteInitiativeFollowUpInput,
+  UpdateInitiativeItemInput,
+  UpdateInitiativePolicyInput,
 } from '@cat-factory/contracts'

package/app/types/recurring.ts

@@ -9,6 +9,7 @@
 export type {
   ScheduleTemplate,
   Recurrence,
+  IssueIntakeConfig,
   PipelineSchedule,
   ScheduleRun,
   CreateScheduleInput,

package/app/utils/catalog.ts

@@ -51,16 +51,18 @@ export const AGENT_ARCHETYPES: AgentArchetype[] = [
     resultView: 'clarity-review',
   },
   {
-    // A read-only `/explore` agent (like the architect), so it's a first-class palette block
-    // a user can add to any pipeline — not just the `pl_bugfix` preset where it leads. No
-    // `resultView`: the enriched report is prose, so it uses the generic step-detail panel.
+    // A read-only, structured `container-explore` agent, so it's a first-class palette block a
+    // user can add to any pipeline — not just the `pl_bugfix` preset where it leads. Its
+    // structured triage opens in the shared generic viewer; the clarity gate consumes its
+    // `clarity`/`questions` server-side.
     kind: 'bug-investigator',
     label: 'Bug Investigator',
     icon: 'i-lucide-search-code',
     color: '#38bdf8',
     category: 'review',
     description:
-      'Read-only codebase investigation that traces the bug to its root cause and produces an enriched report (no code changes).',
+      'Read-only, multi-repo codebase investigation that traces the bug to its root cause and decides whether the report is fixable as-is or needs the reporter to clarify (no code changes).',
+    resultView: 'generic-structured',
   },
   {
     kind: 'task-estimator',

package/app/utils/fragmentPicker.spec.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest'
+import type { PromptFragment } from '~/types/domain'
+import { buildFragmentPickerGroups } from './fragmentPicker'
+
+const frag = (id: string, category: string, title = id): PromptFragment =>
+  ({ id, version: '1.0.0', title, category, summary: '', body: '' }) as PromptFragment
+
+const pool: PromptFragment[] = [
+  frag('node.best-practices', 'Node', 'Node best practices'),
+  frag('node.performance', 'Node', 'Node performance'),
+  frag('style.anti-llmisms', 'Writing style', 'Avoid LLM tells'),
+  frag('style.concise-actionable', 'Writing style', 'Concise and actionable'),
+]
+
+describe('buildFragmentPickerGroups', () => {
+  it('buckets fragments into one labelled group per category (technical + writing-style tracks)', () => {
+    const groups = buildFragmentPickerGroups(
+      pool,
+      () => false,
+      () => {},
+    )
+    // One group per category, each led by a non-interactive `type: 'label'` heading.
+    expect(groups.map((g) => g[0])).toEqual([
+      { type: 'label', label: 'Node' },
+      { type: 'label', label: 'Writing style' },
+    ])
+    // The heading is followed by that category's item labels, in pool order.
+    expect(groups[0]!.slice(1).map((i) => i.label)).toEqual([
+      'Node best practices',
+      'Node performance',
+    ])
+    expect(groups[1]!.slice(1).map((i) => i.label)).toEqual([
+      'Avoid LLM tells',
+      'Concise and actionable',
+    ])
+  })
+
+  it('omits already-selected fragments, dropping a category that empties out', () => {
+    const selected = new Set(['style.anti-llmisms', 'style.concise-actionable'])
+    const groups = buildFragmentPickerGroups(
+      pool,
+      (id) => selected.has(id),
+      () => {},
+    )
+    // Writing style fully selected → its category disappears entirely (no empty labelled group).
+    expect(groups.map((g) => g[0])).toEqual([{ type: 'label', label: 'Node' }])
+  })
+
+  it('invokes onSelect with the fragment id when an item is chosen', () => {
+    const picked: string[] = []
+    const groups = buildFragmentPickerGroups(
+      pool,
+      () => false,
+      (id) => picked.push(id),
+    )
+    // Fire the first real item under the first category (index 1, past the label heading).
+    ;(groups[0]![1] as { onSelect: () => void }).onSelect()
+    expect(picked).toEqual(['node.best-practices'])
+  })
+})

package/app/utils/fragmentPicker.ts

@@ -0,0 +1,32 @@
+import type { DropdownMenuItem } from '@nuxt/ui'
+import type { PromptFragment } from '~/types/domain'
+
+/**
+ * Build the category-grouped groups for a fragment "add" dropdown: the pool fragments not
+ * already selected, bucketed by `category`, each bucket prefixed with a non-interactive
+ * `type: 'label'` heading so the catalog reads as labelled sections instead of one flat,
+ * undifferentiated list. This matters now that the catalog spans distinct tracks that a
+ * single block can pin together — the technical collections (Node / React / …) AND the
+ * document Writing-style fragments — so the headings keep the longer, mixed list navigable.
+ *
+ * Category order follows first appearance in `pool`; empty categories are dropped. Each
+ * inner array is one Nuxt UI menu group (rendered divider-separated); callers append their
+ * own trailing groups (e.g. the library-management links) after the returned groups.
+ */
+export function buildFragmentPickerGroups(
+  pool: PromptFragment[],
+  isSelected: (id: string) => boolean,
+  onSelect: (id: string) => void,
+): DropdownMenuItem[][] {
+  const groups = new Map<string, DropdownMenuItem[]>()
+  for (const f of pool) {
+    if (isSelected(f.id)) continue
+    const items = groups.get(f.category) ?? []
+    items.push({ label: f.title, onSelect: () => onSelect(f.id) })
+    groups.set(f.category, items)
+  }
+  return [...groups.entries()].map(([category, items]): DropdownMenuItem[] => [
+    { type: 'label', label: category },
+    ...items,
+  ])
+}

package/app/utils/initiative.ts

@@ -1,10 +1,19 @@
-import type { InitiativeItem, InitiativeItemStatus, InitiativeStatus } from '~/types/domain'
+import type {
+  InitiativeFollowUp,
+  InitiativeItem,
+  InitiativeItemStatus,
+  InitiativeStatus,
+} from '~/types/domain'
 
 // Shared initiative presentation vocabulary, so the board card, the inspector body and
 // the tracker window render statuses/progress from ONE source. The exhaustive
-// `Record<Enum, string>` maps keep the tier-2 typecheck guard live (a new status without
+// `Record<Enum, …>` maps keep the tier-2 typecheck guard live (a new status without
 // a label/chip fails the build) without triplicating it across the components.
 
+/** Nuxt UI badge/chip colour names — mirrors `UBadge`'s `color` prop union, so a chip map
+ *  types its values against it and the `:color` binding needs no cast. */
+type BadgeColor = 'error' | 'info' | 'primary' | 'secondary' | 'success' | 'warning' | 'neutral'
+
 /** Initiative lifecycle status → i18n label key. */
 export const INITIATIVE_STATUS_LABEL_KEYS: Record<InitiativeStatus, string> = {
   planning: 'initiative.status.planning',
@@ -16,7 +25,7 @@ export const INITIATIVE_STATUS_LABEL_KEYS: Record<InitiativeStatus, string> = {
 }
 
 /** Initiative lifecycle status → Nuxt UI badge colour. */
-export const INITIATIVE_STATUS_CHIPS: Record<InitiativeStatus, string> = {
+export const INITIATIVE_STATUS_CHIPS: Record<InitiativeStatus, BadgeColor> = {
   planning: 'neutral',
   awaiting_approval: 'warning',
   executing: 'info',
@@ -36,7 +45,7 @@ export const INITIATIVE_ITEM_STATUS_LABEL_KEYS: Record<InitiativeItemStatus, str
 }
 
 /** Tracker item status → Nuxt UI badge colour. */
-export const INITIATIVE_ITEM_STATUS_CHIPS: Record<InitiativeItemStatus, string> = {
+export const INITIATIVE_ITEM_STATUS_CHIPS: Record<InitiativeItemStatus, BadgeColor> = {
   pending: 'neutral',
   in_progress: 'info',
   pr_open: 'warning',
@@ -45,6 +54,20 @@ export const INITIATIVE_ITEM_STATUS_CHIPS: Record<InitiativeItemStatus, string>
   skipped: 'neutral',
 }
 
+/** Follow-up triage status → i18n label key. Exhaustive so a new status fails the build. */
+export const INITIATIVE_FOLLOWUP_STATUS_LABEL_KEYS: Record<InitiativeFollowUp['status'], string> = {
+  open: 'initiative.followUpStatus.open',
+  promoted: 'initiative.followUpStatus.promoted',
+  dismissed: 'initiative.followUpStatus.dismissed',
+}
+
+/** Follow-up triage status → Nuxt UI badge colour. */
+export const INITIATIVE_FOLLOWUP_STATUS_CHIPS: Record<InitiativeFollowUp['status'], BadgeColor> = {
+  open: 'warning',
+  promoted: 'success',
+  dismissed: 'neutral',
+}
+
 /** Item statuses that count as settled — mirrors the backend terminal-status set. */
 const SETTLED: ReadonlySet<InitiativeItemStatus> = new Set(['done', 'skipped'])
 

package/i18n/locales/en.json

@@ -219,7 +219,17 @@
       "submit": "Add recurring pipeline",
       "addFailedTitle": "Could not add recurring pipeline",
       "onDemand": "On-demand (manual only)",
-      "onDemandHint": "Runs only when you trigger it, with no schedule. Because you are present each time, its task may use an individual-usage subscription model."
+      "onDemandHint": "Runs only when you trigger it, with no schedule. Because you are present each time, its task may use an individual-usage subscription model.",
+      "intake": "Issue intake",
+      "intakeHint": "Each run picks one matching open issue from the tracker and works it end to end.",
+      "intakeNoSources": "Connect a task source first to pull issues from it.",
+      "intakeGithubRepo": "Repository",
+      "intakeTitleFragment": "Title contains",
+      "intakeTitleFragmentPlaceholder": "e.g. crash",
+      "intakeLabels": "Labels",
+      "intakeLabelsPlaceholder": "comma-separated",
+      "intakeIssueType": "Issue type",
+      "intakeInProgressLabel": "In-progress label"
     },
     "failure": {
       "containerFailedToStart": "Container failed to start",
@@ -854,7 +864,8 @@
         "auto_merge_disabled": "The {preset} preset sends every PR to a human, so this one is waiting for review.",
         "no_rationale": "The merger scored the PR but gave no rationale, so the verdict could not be trusted to auto-merge; the PR is waiting for a human to merge.",
         "no_assessment": "The merger did not return a parseable assessment, so the PR is waiting for a human to merge.",
-        "merge_failed": "The scores were within the {preset} thresholds, but the automatic merge could not complete (for example branch protection or a conflict), so the PR is waiting for a human to merge."
+        "merge_failed": "The scores were within the {preset} thresholds, but the automatic merge could not complete (for example branch protection or a conflict), so the PR is waiting for a human to merge.",
+        "merge_partial": "Some of the task's pull requests merged, but a later one could not, so the change is waiting for a human to finish or revert the multi-repo merge."
       },
       "scores": "Scores",
       "axis": {
@@ -4166,6 +4177,26 @@
       "hint": "Continue lets the planner ask follow-ups; Proceed plans with the answers so far.",
       "proceed": "Proceed to plan",
       "continue": "Continue"
+    },
+    "followUpStatus": {
+      "open": "Open",
+      "promoted": "Promoted",
+      "dismissed": "Dismissed"
+    },
+    "curation": {
+      "promote": "Promote to item",
+      "promoteConfirm": "Create item",
+      "dismiss": "Dismiss",
+      "retry": "Retry",
+      "skip": "Skip",
+      "edit": "Edit",
+      "save": "Save",
+      "cancel": "Cancel",
+      "phaseField": "Phase",
+      "itemTitlePlaceholder": "Item title (defaults to the follow-up's)",
+      "maxConcurrentField": "Max concurrent tasks",
+      "defaultPipelineField": "Default pipeline",
+      "failed": "Could not update the initiative"
     }
   }
 }

package/i18n/locales/es.json

@@ -198,7 +198,17 @@
       "submit": "Añadir pipeline recurrente",
       "addFailedTitle": "No se pudo añadir la pipeline recurrente",
       "onDemand": "Bajo demanda (solo manual)",
-      "onDemandHint": "Se ejecuta solo cuando lo activas, sin programación. Como estás presente cada vez, su tarea puede usar un modelo de suscripción de uso individual."
+      "onDemandHint": "Se ejecuta solo cuando lo activas, sin programación. Como estás presente cada vez, su tarea puede usar un modelo de suscripción de uso individual.",
+      "intake": "Admisión de incidencias",
+      "intakeHint": "Cada ejecución toma una incidencia abierta que coincide del rastreador y la resuelve de principio a fin.",
+      "intakeNoSources": "Primero conecta una fuente de tareas para extraer incidencias de ella.",
+      "intakeGithubRepo": "Repositorio",
+      "intakeTitleFragment": "El título contiene",
+      "intakeTitleFragmentPlaceholder": "p. ej. crash",
+      "intakeLabels": "Etiquetas",
+      "intakeLabelsPlaceholder": "separadas por comas",
+      "intakeIssueType": "Tipo de incidencia",
+      "intakeInProgressLabel": "Etiqueta de en progreso"
     },
     "failure": {
       "containerFailedToStart": "El contenedor no pudo iniciarse",
@@ -811,7 +821,8 @@
         "auto_merge_disabled": "El preajuste {preset} envía todos los PR a una persona, así que este espera revisión.",
         "no_rationale": "El fusionador puntuó el PR pero no dio ninguna justificación, así que no se pudo confiar en el veredicto para fusionar automáticamente; el PR espera a que una persona lo fusione.",
         "no_assessment": "El fusionador no devolvió una evaluación analizable, por lo que el PR espera a que una persona lo fusione.",
-        "merge_failed": "Las puntuaciones estaban dentro de los umbrales de {preset}, pero la fusión automática no pudo completarse (por ejemplo, protección de rama o un conflicto), por lo que el PR espera a que una persona lo fusione."
+        "merge_failed": "Las puntuaciones estaban dentro de los umbrales de {preset}, pero la fusión automática no pudo completarse (por ejemplo, protección de rama o un conflicto), por lo que el PR espera a que una persona lo fusione.",
+        "merge_partial": "Algunas de las solicitudes de incorporación de la tarea se fusionaron, pero una posterior no pudo, por lo que el cambio espera a que una persona termine o revierta la fusión multirrepositorio."
       },
       "scores": "Puntuaciones",
       "axis": {
@@ -4048,6 +4059,26 @@
       "hint": "Continuar permite al planificador hacer mas preguntas; Proceder planifica con las respuestas actuales.",
       "proceed": "Proceder a planificar",
       "continue": "Continuar"
+    },
+    "followUpStatus": {
+      "open": "Abierto",
+      "promoted": "Promovido",
+      "dismissed": "Descartado"
+    },
+    "curation": {
+      "promote": "Promover a elemento",
+      "promoteConfirm": "Crear elemento",
+      "dismiss": "Descartar",
+      "retry": "Reintentar",
+      "skip": "Omitir",
+      "edit": "Editar",
+      "save": "Guardar",
+      "cancel": "Cancelar",
+      "phaseField": "Fase",
+      "itemTitlePlaceholder": "Titulo del elemento (por defecto el del seguimiento)",
+      "maxConcurrentField": "Tareas concurrentes maximas",
+      "defaultPipelineField": "Pipeline por defecto",
+      "failed": "No se pudo actualizar la iniciativa"
     }
   }
 }

package/i18n/locales/fr.json

@@ -198,7 +198,17 @@
       "submit": "Ajouter la pipeline récurrente",
       "addFailedTitle": "Impossible d’ajouter la pipeline récurrente",
       "onDemand": "À la demande (manuel uniquement)",
-      "onDemandHint": "Ne s'exécute que lorsque vous le déclenchez, sans planification. Comme vous êtes présent à chaque fois, sa tâche peut utiliser un modèle d'abonnement à usage individuel."
+      "onDemandHint": "Ne s'exécute que lorsque vous le déclenchez, sans planification. Comme vous êtes présent à chaque fois, sa tâche peut utiliser un modèle d'abonnement à usage individuel.",
+      "intake": "Prise en charge des tickets",
+      "intakeHint": "Chaque exécution sélectionne un ticket ouvert correspondant dans le suivi et le traite de bout en bout.",
+      "intakeNoSources": "Connectez d'abord une source de tâches pour en extraire des tickets.",
+      "intakeGithubRepo": "Dépôt",
+      "intakeTitleFragment": "Le titre contient",
+      "intakeTitleFragmentPlaceholder": "ex. crash",
+      "intakeLabels": "Étiquettes",
+      "intakeLabelsPlaceholder": "séparées par des virgules",
+      "intakeIssueType": "Type de ticket",
+      "intakeInProgressLabel": "Étiquette en cours"
     },
     "failure": {
       "containerFailedToStart": "Le conteneur n’a pas pu démarrer",
@@ -811,7 +821,8 @@
         "auto_merge_disabled": "Le préréglage {preset} envoie chaque PR à une personne ; celle-ci attend donc une revue.",
         "no_rationale": "Le fusionneur a évalué la PR mais n'a donné aucune justification, le verdict n'a donc pas pu être approuvé pour une fusion automatique ; la PR attend une fusion par une personne.",
         "no_assessment": "Le fusionneur n'a pas renvoyé d'évaluation exploitable, la PR attend donc une fusion par une personne.",
-        "merge_failed": "Les scores étaient dans les seuils de {preset}, mais la fusion automatique n'a pas pu aboutir (par exemple protection de branche ou conflit), la PR attend donc une fusion par une personne."
+        "merge_failed": "Les scores étaient dans les seuils de {preset}, mais la fusion automatique n'a pas pu aboutir (par exemple protection de branche ou conflit), la PR attend donc une fusion par une personne.",
+        "merge_partial": "Certaines des pull requests de la tâche ont été fusionnées, mais une suivante n'a pas pu l'être, le changement attend donc qu'une personne termine ou annule la fusion multi-dépôt."
       },
       "scores": "Scores",
       "axis": {
@@ -4048,6 +4059,26 @@
       "hint": "Continuer permet au planificateur de poser des questions complementaires ; Proceder planifie avec les reponses actuelles.",
       "proceed": "Proceder a la planification",
       "continue": "Continuer"
+    },
+    "followUpStatus": {
+      "open": "Ouvert",
+      "promoted": "Promu",
+      "dismissed": "Rejete"
+    },
+    "curation": {
+      "promote": "Promouvoir en element",
+      "promoteConfirm": "Creer l'element",
+      "dismiss": "Rejeter",
+      "retry": "Reessayer",
+      "skip": "Ignorer",
+      "edit": "Modifier",
+      "save": "Enregistrer",
+      "cancel": "Annuler",
+      "phaseField": "Phase",
+      "itemTitlePlaceholder": "Titre de l'element (par defaut celui du suivi)",
+      "maxConcurrentField": "Taches simultanees maximales",
+      "defaultPipelineField": "Pipeline par defaut",
+      "failed": "Impossible de mettre a jour l'initiative"
     }
   }
 }

package/i18n/locales/he.json

@@ -198,7 +198,17 @@
       "submit": "הוסף צינור מחזורי",
       "addFailedTitle": "לא ניתן היה להוסיף צינור מחזורי",
       "onDemand": "לפי דרישה (ידני בלבד)",
-      "onDemandHint": "רץ רק כשאתה מפעיל אותו, ללא תזמון. מכיוון שאתה נוכח בכל פעם, המשימה יכולה להשתמש במודל מנוי לשימוש אישי."
+      "onDemandHint": "רץ רק כשאתה מפעיל אותו, ללא תזמון. מכיוון שאתה נוכח בכל פעם, המשימה יכולה להשתמש במודל מנוי לשימוש אישי.",
+      "intake": "קליטת תקלות",
+      "intakeHint": "כל הרצה בוחרת תקלה פתוחה תואמת אחת מהמעקב ומטפלת בה מקצה לקצה.",
+      "intakeNoSources": "חבר תחילה מקור משימות כדי למשוך ממנו תקלות.",
+      "intakeGithubRepo": "מאגר",
+      "intakeTitleFragment": "הכותרת מכילה",
+      "intakeTitleFragmentPlaceholder": "למשל crash",
+      "intakeLabels": "תוויות",
+      "intakeLabelsPlaceholder": "מופרדות בפסיקים",
+      "intakeIssueType": "סוג תקלה",
+      "intakeInProgressLabel": "תווית בתהליך"
     },
     "failure": {
       "containerFailedToStart": "מכל הקונטיינר נכשל בהפעלה",
@@ -811,7 +821,8 @@
         "auto_merge_disabled": "הקדם-הגדרה {preset} שולחת כל PR לאדם, ולכן זה ממתין לבדיקה.",
         "no_rationale": "הממזג נתן ציון ל-PR אך לא סיפק נימוק, ולכן לא ניתן היה לסמוך על ההכרעה למיזוג אוטומטי; ה-PR ממתין למיזוג ידני.",
         "no_assessment": "הממזג לא החזיר הערכה שניתן לפענח, ולכן ה-PR ממתין למיזוג ידני.",
-        "merge_failed": "הציונים היו בתוך ספי {preset}, אך המיזוג האוטומטי לא הושלם (למשל הגנת ענף או התנגשות), ולכן ה-PR ממתין למיזוג ידני."
+        "merge_failed": "הציונים היו בתוך ספי {preset}, אך המיזוג האוטומטי לא הושלם (למשל הגנת ענף או התנגשות), ולכן ה-PR ממתין למיזוג ידני.",
+        "merge_partial": "חלק מבקשות המשיכה של המשימה מוזגו, אך אחת מאוחרת יותר נכשלה, ולכן השינוי ממתין שאדם ישלים או יבטל את המיזוג הרב-מאגרי."
       },
       "scores": "ציונים",
       "axis": {
@@ -4059,6 +4070,26 @@
       "hint": "המשך מאפשר למתכנן לשאול שאלות המשך; עבור לתכנון מתכנן עם התשובות עד כה.",
       "proceed": "עבור לתכנון",
       "continue": "המשך"
+    },
+    "followUpStatus": {
+      "open": "פתוח",
+      "promoted": "קודם",
+      "dismissed": "נדחה"
+    },
+    "curation": {
+      "promote": "קדם לפריט",
+      "promoteConfirm": "צור פריט",
+      "dismiss": "התעלם",
+      "retry": "נסה שוב",
+      "skip": "דלג",
+      "edit": "ערוך",
+      "save": "שמור",
+      "cancel": "בטל",
+      "phaseField": "שלב",
+      "itemTitlePlaceholder": "כותרת הפריט (ברירת מחדל: של המעקב)",
+      "maxConcurrentField": "מקסימום משימות במקביל",
+      "defaultPipelineField": "צינור ברירת מחדל",
+      "failed": "לא ניתן לעדכן את היוזמה"
     }
   }
 }