Skip to content
← Processus

Les PR mergées font avancer les tickets et un résumé part

Chaque pull request mergée est rattachée à son ticket, avancée sur le board, et regroupée dans un résumé pour l'équipe.

Linear→Slack
Démarre
Pull request mergée
Étapes
4
Contrôles et conditions
0
Une personne décide
Jamais, tourne seul

Déclencheur · Événement

Pull request mergée

Un merge déclenche l'exécution dès qu'il arrive, si bien que le board le reflète avant que quiconque ne demande où ça en est.

Claude exécute la suite en autonomie

  1. 1

    Lister les pull requests mergées du jour

    Chaque pull request mergée depuis la veille, sur tous les dépôts qui comptent, est listée.

  2. 2

    Rattacher chaque PR à son ticket

    Linear

    Linear

    Chaque pull request est associée à son ticket, d'abord par une référence explicite, sinon par une correspondance prudente par mot-clé sur les tickets ouverts.

  3. 3

    Faire avancer chaque ticket rattaché

    Linear

    Linear

    Chaque ticket rattaché reçoit un commentaire nommant sa PR et avance d'un cran une fois mergé, davantage une fois confirmé en ligne.

  4. 4

    Publier un résumé de ce qui a été livré

    Slack

    Slack

    L'équipe reçoit un court message par jour, groupé par dépôt, nommant ce qui a été livré et où ça en est.

Garder un board fidèle à ce qui a réellement été livré est une corvée permanente : quelqu'un doit se souvenir quelle PR a fermé quel ticket, cliquer sur chacune, l'avancer, puis séparément dire à l'équipe ce qui vient d'atterrir. Un jour chargé, c'est la dernière partie qu'on saute en premier.

Les deux moitiés existent déjà comme données. Un code host comme GitHub sait déjà exactement ce qui a été mergé et quand ; un tracker de tickets connaît déjà le statut de chaque ticket ouvert. Le travail, c'est lire l'un, rattacher à l'autre et réécrire, la même jointure chaque jour, à quelque heure que personne ne veut faire ça à la main. Ce qui en fait un travail naturel pour un agent IA placé entre le code host et Linear.

What you get

Every merged pull request is reflected on the board, the matching ticket moves forward with a comment explaining why, and the team gets one short summary of what shipped.

Ce que lit l'automatisation des pull requests mergées

L'exécution liste chaque pull request mergée depuis la veille, sur tous les dépôts qui comptent, avec son titre, sa description et son horaire de merge. Le code host est lu via l'accès dont l'assistant dispose déjà ; ce n'est pas quelque chose que Tulina connecte. Le tracker de tickets et l'outil de messagerie d'équipe sont les deux connexions faites dans Tulina.

La fenêtre reste courte volontairement, un jour plutôt qu'une semaine. C'est ce qui rend l'exécution idempotente : déclenchée deux fois par accident, la seconde passe reconfirme ce que la première avait déjà fait plutôt que de retraiter un arriéré qui grandit.

Rattacher chaque pull request à son ticket

Le premier endroit à regarder, c'est la pull request elle-même. La plupart des PR ouvertes contre un vrai ticket le mentionnent quelque part dans le titre ou la description, et cette référence explicite est un rattachement rapide et précis.

Sans référence, l'agent compare le titre de la PR aux tickets ouverts de l'équipe par mot-clé, et ne retient ce rattachement que s'il en est vraiment sûr. La rigueur du rattachement, c'est ce qui fait gagner ou perdre la confiance ici : un mauvais rattachement fait avancer le mauvais travail, et la personne qui le remarque n'est rarement pas celle qui a lancé l'automatisation. Une PR non rattachée laisse le board tranquille et apparaît quand même dans le résumé, donc rien ne merge silencieusement.

Rien de tout ce rattachement n'est spécifique à Linear. Une référence explicite d'abord, puis un repli prudent par mot-clé, fonctionne de la même façon contre n'importe quel tracker que l'assistant peut atteindre.

Faire avancer les tickets, et seulement avancer

Avant de changer quoi que ce soit, l'agent lit l'état actuel du ticket. Un ticket déjà plus avancé que ce que « code mergé » suggérerait (en revue, en attente d'une personne précise, déjà livré) reste exactement où il est. Le travail consiste à remettre le board à jour, jamais à écraser une décision qu'une personne a prise plus récemment que cette exécution.

Chaque avancée est précédée d'un commentaire nommant la pull request précise, avec son titre et son lien. Un statut qui change sans trace du pourquoi est indiscernable d'un statut qui est faux.

L'état cible suit ce qui est réellement connu. Mergé est un signal ; confirmé en ligne dans un environnement de préproduction ou de staging en est un plus fort, et l'agent ne le revendique pas sans vérifier. Certains dépôts déploient dès qu'une pull request atterrit sur la branche principale, d'autres ont besoin d'une étape séparée, et les deux sont faciles à confondre sans vérifier dépôt par dépôt. Distinguer les deux, c'est ce qui garde « Terminé » vraiment terminé.

Un résumé de ce qui a été livré

L'équipe reçoit un court message dans Slack, groupé par dépôt, en sautant les dépôts sans rien de mergé. Chaque pull request apparaît avec son titre, son ticket s'il en a un, et si elle est mergée ou confirmée en ligne.

Un jour où rien n'a mergé nulle part, le message le dit aussi. Une routine qui reste silencieuse un jour calme est indiscernable d'une routine cassée.

The prompt

The real prompt behind the steps above, detailed enough that an agent with the same tools can run it as written. The Run buttons copy the full version, which also carries the steps for connecting those tools.

# Turn merged into Slack notif and ticket update

You have access to issue tracking and team messaging, plus your own read
access to wherever your team's code lives (most coding assistants already
have this — a code host isn't something Tulina connects to). Run this
for **[your repos]**.


## 1. List the day's merged pull requests

- Pull every pull request merged in the last day, across every repo that
  matters — title, description, and merge time.
- Keep the lookback window short (a day, not a week). That's what makes
  this idempotent: run it twice by accident and the second pass just
  re-confirms what the first already did, instead of re-processing a
  growing backlog.

## 2. Match each PR to its ticket

- Check the PR title and description first for an explicit ticket
  reference — most PRs opened against a real ticket mention it
  somewhere, and that match is fast and precise.
- If nothing explicit turns up, compare the PR's title against your
  team's open tickets by keyword. Only take this match if you're
  genuinely confident — a wrong match is worse than leaving a PR
  unmatched, since it moves the wrong piece of work forward.
- A PR with no confident match still counts for the summary in step 4 —
  it just doesn't touch the board.

## 3. Move each matched ticket forward

- Before changing anything, read the ticket's current state. Never move
  a ticket backwards, and never touch one that's already further along
  than "code merged" would suggest.
- Leave a comment naming the specific PR — title and link — before
  changing status. A status that changes with no trace of why is
  indistinguishable from a status that's wrong.
- Decide the target state from what you actually know: merged alone is
  one signal, confirmed live in your preprod or staging environment is a
  stronger one. Don't claim the stronger one without checking — some
  repos deploy the moment a PR lands on the main branch, others need a
  separate step first, and the two are easy to conflate if you don't
  check per repo.

## 4. Post one summary of what shipped

- One short message, grouped by repo, skipping repos with nothing
  merged.
- For each PR: title, the ticket it maps to if any, and whether it's
  just merged or confirmed live.
- If nothing merged anywhere today, say that too — a routine that stays
  quiet on a quiet day is indistinguishable from a routine that's
  broken.

## Output

Report: how many PRs found, how many matched to a ticket, how many
tickets moved, and anything skipped and why.

Pourquoi le faire tourner avec Tulina

Un prompt aide une personne. Un processus fait avancer une équipe.

Collé dans une conversation, le prompt ci-dessus marche une fois, pour celui qui l'a collé. Dans Tulina, « Les PR mergées font avancer les tickets et un résumé part » devient un processus que l'équipe partage, qui garde son historique, qui tourne seul, et qui reste dans le même périmètre de sécurité que les outils qu'il appelle.

  • Toute l'équipe travaille sur le même

    PersonnelÉquipeOrganisation

    Un processus se range à l'endroit qui lui correspond : à vous, à votre équipe ou à toute l'organisation. Celui qui l'exécute peut l'améliorer, et tout le monde repart de la meilleure version au lieu de réexpliquer le travail à chaque fois.

  • Chaque modification est une version

    v1v2v3

    Chaque changement crée une nouvelle version et garde la précédente ; une mauvaise modification se défait en restaurant une version antérieure. Chaque exécution enregistre la version qu'elle a suivie, et ce qu'elle a appris revient dans le processus.

  • Il tourne sans vous

    planifiéwebhookà la demande

    Un agent hébergé exécute le processus sur l'infrastructure de Tulina, à heure fixe ou quand un événement arrive, et continue quand vous fermez la conversation. Rien à héberger. Chaque exécution est suivie jusqu'à son résultat.

  • Dans le même périmètre de sécurité

    coffrerôlesjournal

    Les identifiants restent dans le coffre, jamais dans le prompt. Les rôles décident qui peut lancer quoi, chaque appel est journalisé, et une étape qu'une personne doit valider attend cette personne.

Questions sur la mise à jour des tickets depuis les PR mergées

Oui. Un agent avec accès au tracker de tickets et un accès en lecture au code host peut lister les pull requests mergées du jour, rattacher chacune à son ticket, laisser un commentaire nommant la PR, et faire avancer le ticket. L'équipe reçoit ensuite un court résumé de ce qui a été livré.

Elle cherche d'abord une référence explicite au ticket dans le titre et la description de la PR, ce qui est rapide et précis. Sans référence, elle compare le titre aux tickets ouverts par mot-clé et ne retient un rattachement que si elle en est vraiment sûre. Une PR sans rattachement fiable ne touche pas le board mais apparaît quand même dans le résumé, donc rien ne merge silencieusement.

Non — l'agent lit l'état actuel d'un ticket avant d'y toucher, et ne le fait avancer qu'à partir de là où il en était déjà.

Une intégration native se contente généralement de lier une PR à un ticket. Celle-ci décide aussi quoi en faire — faire avancer le ticket ou non, selon que le code est mergé ou confirmé en ligne — et rédige un résumé en langage clair, lisible par quelqu'un qui ne code pas.

D'autres processus qui tournent surtout sur Linear. Les outils partagés avec celui-ci sont allumés.

Découvrez Tulina en 30 minutes.

Réserver une démo