@cat-factory/app 0.87.5 → 0.89.0

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/domain.ts

@@ -24,6 +24,8 @@ export type {
   CreateTaskType,
   TaskTypeFields,
   DocKind,
+  DocKindFieldKey,
+  DocKindFieldSpec,
   Block,
   PullRequestRef,
   CloudProvider,
@@ -74,9 +76,10 @@ export type {
 
 import type { AgentCategory, AgentKind } from '@cat-factory/contracts'
 
-// The document-kind list is a runtime value (used to render the picker), so it is re-exported
-// as a value — the single source of truth lives in the contracts package.
-export { DOC_KINDS } from '@cat-factory/contracts'
+// The document-kind list + the per-kind field descriptors are runtime values (used to render
+// the picker and the conditional per-kind inputs), so they are re-exported as values — the
+// single source of truth lives in the contracts package.
+export { DOC_KINDS, DOC_KIND_FIELDS } from '@cat-factory/contracts'
 
 /** A draggable agent definition shown in the agent palette. Frontend-only. */
 export interface AgentArchetype {

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/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

@@ -169,6 +169,49 @@
       "targetPathPlaceholder": "e.g. docs/rfcs/0001-foo.md",
       "outlineHints": "Outline hints",
       "outlineHintsPlaceholder": "Sections or points the document should cover",
+      "docFields": {
+        "targetUsers": {
+          "label": "Target users",
+          "placeholder": "Who the document is for and the jobs they're doing"
+        },
+        "successMetrics": {
+          "label": "Success metrics",
+          "placeholder": "Measurable outcomes that show it's working"
+        },
+        "alternativesConsidered": {
+          "label": "Alternatives considered",
+          "placeholder": "Other approaches weighed and why they were ruled out"
+        },
+        "rolloutConcerns": {
+          "label": "Rollout concerns",
+          "placeholder": "Migration and rollout risks to address"
+        },
+        "decisionDrivers": {
+          "label": "Decision drivers",
+          "placeholder": "The forces and constraints driving the decision"
+        },
+        "consideredOptions": {
+          "label": "Considered options",
+          "placeholder": "The options evaluated, each with its trade-offs"
+        },
+        "whenToUse": {
+          "label": "When to use",
+          "placeholder": "The trigger or situation this runbook applies to"
+        },
+        "escalationPath": {
+          "label": "Escalation path",
+          "placeholder": "Who to contact and how to escalate on failure"
+        },
+        "researchQuestion": {
+          "label": "Research question",
+          "placeholder": "The question or hypothesis to answer"
+        },
+        "optionsToCompare": {
+          "label": "Options to compare",
+          "placeholder": "The options to weigh against each other"
+        },
+        "apiSurface": { "label": "API surface", "placeholder": "The endpoints or surface in scope" }
+      },
       "optional": "optional",
       "pipeline": "Pipeline",
       "chooseAtRunTime": "Choose at run time",
@@ -219,7 +262,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 +907,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 +4220,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

@@ -151,6 +151,52 @@
       "targetPathPlaceholder": "p. ej. docs/rfcs/0001-foo.md",
       "outlineHints": "Sugerencias de esquema",
       "outlineHintsPlaceholder": "Secciones o puntos que el documento debería cubrir",
+      "docFields": {
+        "targetUsers": {
+          "label": "Usuarios objetivo",
+          "placeholder": "Para quién es el documento y las tareas que realizan"
+        },
+        "successMetrics": {
+          "label": "Métricas de éxito",
+          "placeholder": "Resultados medibles que indican que funciona"
+        },
+        "alternativesConsidered": {
+          "label": "Alternativas consideradas",
+          "placeholder": "Otros enfoques evaluados y por qué se descartaron"
+        },
+        "rolloutConcerns": {
+          "label": "Consideraciones de despliegue",
+          "placeholder": "Riesgos de migración y despliegue a tener en cuenta"
+        },
+        "decisionDrivers": {
+          "label": "Factores de decisión",
+          "placeholder": "Las fuerzas y restricciones que motivan la decisión"
+        },
+        "consideredOptions": {
+          "label": "Opciones consideradas",
+          "placeholder": "Las opciones evaluadas, cada una con sus ventajas y desventajas"
+        },
+        "whenToUse": {
+          "label": "Cuándo usarlo",
+          "placeholder": "El desencadenante o la situación en que aplica este runbook"
+        },
+        "escalationPath": {
+          "label": "Ruta de escalado",
+          "placeholder": "A quién contactar y cómo escalar si falla"
+        },
+        "researchQuestion": {
+          "label": "Pregunta de investigación",
+          "placeholder": "La pregunta o hipótesis a responder"
+        },
+        "optionsToCompare": {
+          "label": "Opciones a comparar",
+          "placeholder": "Las opciones a sopesar entre sí"
+        },
+        "apiSurface": {
+          "label": "Superficie de API",
+          "placeholder": "Los endpoints o la superficie dentro del alcance"
+        }
+      },
       "optional": "opcional",
       "pipeline": "Pipeline",
       "chooseAtRunTime": "Elegir al ejecutar",
@@ -198,7 +244,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 +867,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 +4105,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

@@ -151,6 +151,52 @@
       "targetPathPlaceholder": "ex. docs/rfcs/0001-foo.md",
       "outlineHints": "Indications de plan",
       "outlineHintsPlaceholder": "Sections ou points que le document devrait couvrir",
+      "docFields": {
+        "targetUsers": {
+          "label": "Utilisateurs cibles",
+          "placeholder": "À qui s'adresse le document et les tâches qu'ils accomplissent"
+        },
+        "successMetrics": {
+          "label": "Indicateurs de réussite",
+          "placeholder": "Résultats mesurables qui montrent que ça fonctionne"
+        },
+        "alternativesConsidered": {
+          "label": "Alternatives envisagées",
+          "placeholder": "Les autres approches évaluées et pourquoi elles ont été écartées"
+        },
+        "rolloutConcerns": {
+          "label": "Points de déploiement",
+          "placeholder": "Risques de migration et de déploiement à traiter"
+        },
+        "decisionDrivers": {
+          "label": "Facteurs de décision",
+          "placeholder": "Les forces et contraintes qui motivent la décision"
+        },
+        "consideredOptions": {
+          "label": "Options envisagées",
+          "placeholder": "Les options évaluées, chacune avec ses compromis"
+        },
+        "whenToUse": {
+          "label": "Quand l'utiliser",
+          "placeholder": "Le déclencheur ou la situation à laquelle ce runbook s'applique"
+        },
+        "escalationPath": {
+          "label": "Chemin d'escalade",
+          "placeholder": "Qui contacter et comment escalader en cas d'échec"
+        },
+        "researchQuestion": {
+          "label": "Question de recherche",
+          "placeholder": "La question ou l'hypothèse à laquelle répondre"
+        },
+        "optionsToCompare": {
+          "label": "Options à comparer",
+          "placeholder": "Les options à mettre en balance"
+        },
+        "apiSurface": {
+          "label": "Surface d'API",
+          "placeholder": "Les endpoints ou la surface concernés"
+        }
+      },
       "optional": "optionnel",
       "pipeline": "Pipeline",
       "chooseAtRunTime": "Choisir au lancement",
@@ -198,7 +244,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 +867,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 +4105,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"
     }
   }
 }