From 0d7a01b450ca356a2b5a868237c0dc54fa61bb5f Mon Sep 17 00:00:00 2001
From: Shaenn <22753401+Shaenn@users.noreply.github.com>
Date: Thu, 3 Sep 2026 01:14:53 +0200
Subject: [PATCH 1/9] =?UTF-8?q?Un=20flux=20coup=C3=A9=20ne=20laisse=20plus?=
 =?UTF-8?q?=20l'=C3=A9cran=20affirmer=20ce=20qu'il=20ne=20sait=20plus?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`EventSource` se reconnaît seul, et le `snapshot` qui suit remet tout d'aplomb :
la coupure n'est pas une panne. Mais tant qu'elle dure, la dernière phase reçue
restait affichée avec son chrono qui montait — il tourne côté client. Une session
coupée pendant un compactage annonçait ainsi un compactage qui n'avait plus lieu,
sous un statut « Au travail » figé à la dernière trame.

`connected` existait et n'était pas déstructuré par la page. Il ne suffisait pas
non plus : faux entre l'ouverture et la première trame, il aurait annoncé une
perte là où il n'y avait qu'une attente. D'où `lost`, qui ne se lève qu'après un
flux qui a vécu.

Les outils en vol s'arrêtent de battre du même geste : ils viennent d'`activity`,
que la coupure remet à `IDLE_ACTIVITY`.

Au passage : une erreur appartient au statut qui la porte. Sans cette remise à
zéro, celle d'un tour ancien restait sous le composeur pour le reste de la
session, y compris après une reprise réussie.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/composables/useLiveSession.ts | 32 ++++++++++++++++++++++++++++---
 src/i18n/en/pages/atelier.ts      |  1 +
 src/i18n/fr/pages/atelier.ts      |  3 +++
 src/pages/AtelierPage.vue         | 18 +++++++++++++++--
 4 files changed, 49 insertions(+), 5 deletions(-)

diff --git a/src/composables/useLiveSession.ts b/src/composables/useLiveSession.ts
index 31b0340..0a7bf68 100644
--- a/src/composables/useLiveSession.ts
+++ b/src/composables/useLiveSession.ts
@@ -36,6 +36,15 @@ export function useLiveSession() {
   const permissions = ref<PermissionRequest[]>([])
   const asks = ref<AskRequest[]>([])
   const connected = ref(false)
+  /**
+   * Le lien a été établi, puis rompu — et pas encore rétabli.
+   *
+   * `connected` seul ne suffit pas à le dire : il est faux entre l'ouverture de
+   * la page et la première trame, où il n'y a pourtant rien d'anormal à
+   * signaler. Ce drapeau ne se lève qu'après un flux qui a vécu, et retombe dès
+   * qu'il reprend.
+   */
+  const lost = ref(false)
   /**
    * Ce que l'agent fait à l'instant. Un état à part de la timeline : il ne
    * s'ajoute à rien, il se remplace — et il n'a pas de passé.
@@ -69,6 +78,8 @@ export function useLiveSession() {
 
   let source: EventSource | null = null
   let attached = ''
+  /** Le flux a-t-il déjà porté quelque chose ? Voir `lost`. */
+  let opened = false
   let commandsAsked = false
   let filesAsked = false
   const index = new Map<string, number>()
@@ -150,7 +161,10 @@ export function useLiveSession() {
 
       case 'status':
         status.value = upsert.status
-        if (upsert.error) error.value = upsert.error
+        // Une erreur appartient au statut qui la porte : sans cette remise à
+        // zéro, celle d'un tour ancien restait sous le composeur pour le reste
+        // de la session, y compris après une reprise réussie.
+        error.value = upsert.error ?? ''
         if (session.value) session.value.status = upsert.status
         return
 
@@ -235,16 +249,25 @@ export function useLiveSession() {
     filesTruncated.value = false
     filesAsked = false
     attached = runId
+    opened = false
     index.clear()
 
     source = new EventSource(streamUrl(runId))
     source.onopen = () => {
       connected.value = true
+      lost.value = false
+      opened = true
     }
     source.onerror = () => {
-      // `EventSource` se reconnecte seul ; le `snapshot` qui suivra remettra
-      // l'état d'aplomb. On ne signale donc qu'une coupure visible, pas une panne.
+      // `EventSource` se reconnecte seul, et le `snapshot` qui suivra remettra
+      // l'état d'aplomb : la coupure n'est donc pas une panne. Mais tant qu'elle
+      // dure, on ne sait plus ce que fait l'agent — et la dernière phase reçue
+      // resterait à l'écran, son chrono montant à vide, parce qu'il tourne ici.
+      // Une session coupée pendant un compactage annonçait ainsi un compactage
+      // qui n'avait plus lieu.
       connected.value = false
+      lost.value = opened
+      activity.value = IDLE_ACTIVITY
     }
     // Le serveur nomme chaque trame de son `kind` : on écoute par nom plutôt que
     // `onmessage`, qui ne reçoit que les trames sans nom.
@@ -276,6 +299,8 @@ export function useLiveSession() {
     source = null
     attached = ''
     connected.value = false
+    lost.value = false
+    opened = false
     // Débranché, on ne sait plus ce qui se passe : laisser la dernière phase
     // affichée ferait croire à une session qu'on regarde encore.
     activity.value = IDLE_ACTIVITY
@@ -291,6 +316,7 @@ export function useLiveSession() {
     permissions,
     asks,
     connected,
+    lost,
     activity,
     commands,
     commandsLoading,
diff --git a/src/i18n/en/pages/atelier.ts b/src/i18n/en/pages/atelier.ts
index 5141948..d59f262 100644
--- a/src/i18n/en/pages/atelier.ts
+++ b/src/i18n/en/pages/atelier.ts
@@ -68,6 +68,7 @@ const atelier: MessageSchema['pages']['atelier'] = {
     failed: 'Stopped on error',
   },
   resumed: 'resumed',
+  lost: 'I’ve lost contact',
   autoScroll: 'Auto-scroll',
   followLive: 'Follow live',
   fullReplay: 'Full replay',
diff --git a/src/i18n/fr/pages/atelier.ts b/src/i18n/fr/pages/atelier.ts
index c2cb787..949fb6a 100644
--- a/src/i18n/fr/pages/atelier.ts
+++ b/src/i18n/fr/pages/atelier.ts
@@ -83,6 +83,9 @@ export default {
     failed: 'Arrêtée sur erreur',
   },
   resumed: 'reprise',
+  // Ce qui est rompu est le flux, pas la session : elle travaille peut-être
+  // encore. La phrase dit donc ce qu'AURA ne voit plus, jamais ce qui a échoué.
+  lost: 'J’ai perdu le contact',
   autoScroll: 'Auto-défilement',
   followLive: 'Suivre le direct',
   fullReplay: 'Rejeu complet',
diff --git a/src/pages/AtelierPage.vue b/src/pages/AtelierPage.vue
index aea6979..61fbccd 100644
--- a/src/pages/AtelierPage.vue
+++ b/src/pages/AtelierPage.vue
@@ -236,8 +236,15 @@
           <!-- Le halo respirant de `status-dot--live`, celui-là même que la page
                d'accueil pose sur une session en activité. L'Atelier, qui est
                *l'*écran d'une session en activité, ne l'avait pas. -->
-          <span class="at-dot" :class="[`at-dot--${status}`, { 'status-dot--live': status === 'working' }]" aria-hidden="true" />
-          <span class="at-status">{{ t(`pages.atelier.status.${status}`) }}</span>
+          <!-- Le lien rompu prime sur le statut : celui-ci date de la dernière
+               trame reçue, et l'annoncer encore ferait dire « Au travail » à une
+               session dont on ne sait plus rien. -->
+          <span
+            class="at-dot"
+            :class="[lost ? 'at-dot--lost' : `at-dot--${status}`, { 'status-dot--live': status === 'working' && !lost }]"
+            aria-hidden="true"
+          />
+          <span class="at-status">{{ lost ? t('pages.atelier.lost') : t(`pages.atelier.status.${status}`) }}</span>
           <!-- Le nom du dossier, pas son chemin : la barre dit où l'on est, et
                un chemin absolu la remplit sans rien apprendre à qui l'a choisi.
                Le chemin complet reste dans l'infobulle, et sur l'écran d'accueil
@@ -580,6 +587,7 @@
     error,
     permissions,
     asks,
+    lost,
     activity,
     commands,
     commandsLoading,
@@ -2126,6 +2134,12 @@
     background: var(--danger);
   }
 
+  /* Un lien rompu n'est pas une session en erreur : elle travaille peut-être
+   encore, c'est nous qui ne la voyons plus. D'où l'ambre et non le rouge. */
+  .at-dot--lost {
+    background: var(--warn);
+  }
+
   .at-status {
     font-size: var(--fs-sm);
     color: var(--text);

From 5f693ed022dfefb37a4eb3501944c6739dfecb39 Mon Sep 17 00:00:00 2001
From: Shaenn <22753401+Shaenn@users.noreply.github.com>
Date: Thu, 3 Sep 2026 01:27:04 +0200
Subject: [PATCH 2/9] =?UTF-8?q?Une=20session=20qui=20s'arr=C3=AAte=20le=20?=
 =?UTF-8?q?dit,=20et=20son=20plantage=20ne=20se=20lit=20plus=20en=20gris?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Deux défauts qui se répondent, et qui laissaient une panne sans témoin.

Le `for await` qui se terminait sans exception posait `ended` et n'écrivait
rien : c'était le seul chemin de fin qui ne passait pas par `appendSystem`. Une
session s'arrêtait donc sans un mot, et l'écran ne distinguait pas cette fin-là
d'un plantage. Un arrêt demandé, lui, a déjà dit ce qu'il était — d'où la garde
sur `stopped`.

Et quand le fil disait quelque chose, il pouvait le dire en gris :
`AssistantTurn` lit `level`, `TimelineNodeView` ne le lisait pas. Un crash sans
tour assistant pour l'accompagner — le cas du premier message — s'affichait sous
l'étiquette « Système », où il ressemblait à une note d'information.

S'y ajoute une trace sur la sortie d'erreur, horodatée et portant le `runId` :
une session qui s'arrête pendant qu'on regarde ailleurs ne laisse aucune trace
ailleurs, et c'est ce qu'il faut pour instruire une panne qu'on ne sait pas
reproduire.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 server/agent/runner.ts                     | 28 ++++++++++++++++++++++
 server/i18n/en.ts                          |  1 +
 server/i18n/fr.ts                          |  9 +++++++
 src/components/replay/TimelineNodeView.vue | 23 ++++++++++++++++--
 4 files changed, 59 insertions(+), 2 deletions(-)

diff --git a/server/agent/runner.ts b/server/agent/runner.ts
index baa94ca..4978f13 100644
--- a/server/agent/runner.ts
+++ b/server/agent/runner.ts
@@ -804,6 +804,25 @@ export class SessionRunner {
 
   // ── La boucle ─────────────────────────────────────────────────────────────
 
+  /**
+   * Ce qui s'écrit dans le terminal du BFF quand une session finit mal.
+   *
+   * Le fil dit à l'utilisateur ce qui s'est passé ; ceci le dit à qui relira
+   * après coup. Les deux sont nécessaires : une session qui s'arrête pendant
+   * qu'on regarde ailleurs ne laisse aucune trace ailleurs qu'ici, et c'est ce
+   * qu'il faut pour instruire une panne qu'on ne sait pas reproduire.
+   *
+   * L'horodatage et le `runId` sont le minimum pour recouper avec le `.jsonl`.
+   */
+  private log(reason: string, cause?: unknown): void {
+    const stack = cause instanceof Error ? cause.stack : undefined
+    // Le journal de Fastify n'est pas joignable d'ici, et ce fichier ne connaît
+    // pas HTTP — c'est l'invariant du runner. La sortie d'erreur est le même
+    // flux que celui où pino écrit ; l'ordre des lignes reste donc lisible.
+    // eslint-disable-next-line no-console
+    console.error(`[atelier] ${new Date().toISOString()} ${this.session.runId} ${reason}`, stack ?? '')
+  }
+
   private async run(): Promise<void> {
     this.query = query({
       prompt: this.queue,
@@ -827,10 +846,19 @@ export class SessionRunner {
       for await (const message of this.query) {
         this.consume(message)
       }
+      // Une fin sans exception, et que personne n'a demandée : le CLI a refermé
+      // son flux tout seul. C'était le seul chemin de fin qui n'écrivait rien —
+      // la session s'arrêtait sans un mot, et l'écran ne distinguait pas cette
+      // fin-là d'un plantage. Un arrêt demandé, lui, a déjà dit ce qu'il était.
+      if (!this.stopped) {
+        this.emit(this.translator.appendSystem(t('agent.streamClosed'), 'error'))
+        this.log('flux refermé sans arrêt demandé')
+      }
       this.setStatus('ended')
     } catch (e) {
       const message = e instanceof Error ? e.message : String(e)
       this.emit(this.translator.appendSystem(t('agent.sessionEnded', { message }), 'error'))
+      this.log(message, e)
       this.setStatus('failed', message)
     } finally {
       this.query = null
diff --git a/server/i18n/en.ts b/server/i18n/en.ts
index b692d34..4c5095d 100644
--- a/server/i18n/en.ts
+++ b/server/i18n/en.ts
@@ -63,6 +63,7 @@ const en: Catalog = {
     sessionStopped: 'Session stopped.',
     deniedFromAtelier: 'Denied from the Workshop.',
     sessionEnded: 'The session stopped: {message}',
+    streamClosed: 'The stream closed on its own. I no longer have a session running; you can resume it.',
     cleared: 'I am opening a new session. The context is empty; the previous exchange stays on disk.',
     clearedByCommand: 'I am opening a new session: /clear emptied the context. The previous exchange stays on disk.',
     pickerUnavailable: 'No folder picker available on {platform}.',
diff --git a/server/i18n/fr.ts b/server/i18n/fr.ts
index 0460fa8..9e2f69b 100644
--- a/server/i18n/fr.ts
+++ b/server/i18n/fr.ts
@@ -71,6 +71,15 @@ export default {
     sessionStopped: 'Session arrêtée.',
     deniedFromAtelier: "Refusé depuis l'Atelier.",
     sessionEnded: "La session s'est arrêtée : {message}",
+    /**
+     * Une fin sans exception : le CLI a refermé son flux de lui-même.
+     *
+     * C'était jusqu'ici le seul chemin de fin qui n'écrivait rien — la session
+     * s'arrêtait sans un mot, et l'écran ne distinguait pas cette fin-là d'un
+     * plantage. Elle ne dit pas de cause parce qu'il n'y en a pas à dire : le
+     * flux s'est refermé, la reprise reste possible.
+     */
+    streamClosed: "Le flux s'est refermé de lui-même. Je n'ai plus de session en cours ; vous pouvez la reprendre.",
     /** Le fil vient d'être vidé : ces deux lignes sont tout ce qui reste à l'écran. */
     cleared: "J'ouvre une nouvelle session. Le contexte est vide ; l'échange précédent reste sur disque.",
     clearedByCommand: "J'ouvre une nouvelle session : /clear a vidé le contexte. L'échange précédent reste sur disque.",
diff --git a/src/components/replay/TimelineNodeView.vue b/src/components/replay/TimelineNodeView.vue
index 6d1baea..36fb49f 100644
--- a/src/components/replay/TimelineNodeView.vue
+++ b/src/components/replay/TimelineNodeView.vue
@@ -38,7 +38,7 @@
       <PlanModeMarker v-else-if="node.event.kind === 'planmode' && node.event.planMode" :mark="node.event.planMode" />
       <CompactSummary v-else-if="node.event.origin === 'compact-summary'" :event="node.event" />
       <CommandLine v-else-if="isCommand" :event="node.event" />
-      <section v-else class="rp-loose">
+      <section v-else class="rp-loose" :class="{ 'rp-loose--error': isError }">
         <p class="rp-loose-head">
           <q-icon :name="looseIcon" size="14px" aria-hidden="true" />
           {{ looseLabel }}
@@ -110,7 +110,21 @@
     return origin === 'slash-command' || origin === 'command-output'
   })
 
-  const looseIcon = computed(() => (props.node.kind !== 'turn' && props.node.event.kind === 'summary' ? 'summarize' : 'info'))
+  /**
+   * Une ligne de service qui annonce une panne.
+   *
+   * `AssistantTurn` lisait déjà `level` ; ce rendu-ci ne le lisait pas. Une
+   * session qui s'arrêtait sans qu'un tour assistant ne l'accompagne — c'est le
+   * cas d'un plantage au premier message — écrivait donc son crash en gris,
+   * sous l'étiquette « Système », où il ressemblait à une note d'information.
+   */
+  const isError = computed(() => props.node.kind !== 'turn' && props.node.event.level === 'error')
+
+  const looseIcon = computed(() => {
+    if (props.node.kind === 'turn') return 'info'
+    if (props.node.event.level === 'error') return 'error_outline'
+    return props.node.event.kind === 'summary' ? 'summarize' : 'info'
+  })
 
   const looseLabel = computed(() => {
     if (props.node.kind === 'turn') return ''
@@ -196,6 +210,11 @@
     flex-direction: column;
     gap: var(--space-xs);
   }
+  /* Le titre porte la couleur, pas le corps : c'est l'étiquette qui disait
+   « information » à tort, et un pavé rouge se lirait comme une alarme. */
+  .rp-loose--error .rp-loose-head {
+    color: var(--danger);
+  }
   .rp-loose-head {
     margin: 0;
     display: flex;

From 0d7e7d64d8f3cc96ab5434ee100da5271f3a3181 Mon Sep 17 00:00:00 2001
From: Shaenn <22753401+Shaenn@users.noreply.github.com>
Date: Thu, 3 Sep 2026 01:27:04 +0200
Subject: [PATCH 3/9] =?UTF-8?q?Le=20corpus=20tenait=20dans=20cinq=20second?=
 =?UTF-8?q?es=20quand=20il=20=C3=A9tait=20plus=20petit?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Quatre tests de `corpus.test.ts` tombaient en dépassement : les cinq secondes de
vitest ont été écrites pour des fixtures, alors que chacun relit soixante
transcrits réels d'un corpus qui ne cesse de grossir. Les propriétés tenaient
pourtant à chaque fois — c'est le délai qui avait vieilli, pas le code.

On allonge plutôt que de réduire l'échantillon : ce fichier est un filet, et un
filet qu'on rétrécit pour qu'il aille plus vite n'attrape plus rien.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 test/corpus.test.ts | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/test/corpus.test.ts b/test/corpus.test.ts
index 560bfbe..373220c 100644
--- a/test/corpus.test.ts
+++ b/test/corpus.test.ts
@@ -55,7 +55,20 @@ function attributedAt(c: SessionContext, i: number): number {
   return CONTEXT_CATEGORIES.reduce((sum, cat) => sum + c.turns[i]!.byCategory[cat], 0)
 }
 
-describe.skipIf(!HAS_CORPUS)('invariants sur ~/.claude', () => {
+/**
+ * Le délai laissé à un test qui lit le vrai disque.
+ *
+ * Les cinq secondes de vitest ont été écrites pour des fixtures ; ici chaque
+ * test relit soixante transcrits réels, et le corpus d'une machine ne cesse de
+ * grossir. Quatre de ces tests tombaient donc en dépassement — un `pnpm verifie`
+ * rouge en permanence, pour une propriété qui tenait pourtant à chaque fois.
+ *
+ * On allonge plutôt que de réduire l'échantillon : ce fichier est un filet, et
+ * un filet qu'on rétrécit pour qu'il aille plus vite n'attrape plus rien.
+ */
+const TIMEOUT_MS = 120_000
+
+describe.skipIf(!HAS_CORPUS)('invariants sur ~/.claude', { timeout: TIMEOUT_MS }, () => {
   const sessions = HAS_CORPUS ? sample() : []
 
   it('trouve des sessions à examiner', () => {

From 6bc8b03b1b7f670fa7392ed299d8ef1872847fc3 Mon Sep 17 00:00:00 2001
From: Shaenn <22753401+Shaenn@users.noreply.github.com>
Date: Thu, 3 Sep 2026 01:31:20 +0200
Subject: [PATCH 4/9] Une session qui meurt puis repart ne perd plus ni son
 tour ni son contexte
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Trois défauts qui ne se voyaient qu'ensemble, sur le chemin de la relance.

Le SDK ne referme pas la file qu'il tenait quand sa boucle meurt : son itérateur
restait inscrit comme destinataire du prochain `push`. L'ordre de `send()` étant
« pousse le prompt, puis relance la boucle », le tour de la reprise partait dans
un générateur que plus personne ne tirait — le message ne partait jamais et la
session restait « au travail » pour toujours. D'où `abandon()`, qui dénoue sans
fermer : la file survit à son consommateur.

La relance repassait le `resume` d'origine, jamais l'identifiant que la session
s'était vu attribuer. Une session née sans reprise recommençait donc une
conversation neuve : même fil à l'écran, aucun souvenir derrière. Et elle le
faisait en silence, ce qui est pire que la panne — elle le dit maintenant, et
elle dit lequel des deux cas s'applique.

Enfin `query()` était construit hors du `try`, et `run()` appelé par `void` : ce
que le constructeur du SDK lève en montant n'avait aucun destinataire. La session
restait « au travail » sans qu'aucun message ne vienne jamais.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 server/agent/queue.ts    | 30 ++++++++++--
 server/agent/runner.ts   | 39 +++++++++++++++-
 server/i18n/en.ts        |  2 +
 server/i18n/fr.ts        |  9 ++++
 test/agent-queue.test.ts | 99 ++++++++++++++++++++++++++++++++++++++++
 5 files changed, 172 insertions(+), 7 deletions(-)
 create mode 100644 test/agent-queue.test.ts

diff --git a/server/agent/queue.ts b/server/agent/queue.ts
index 5baec13..b243a83 100644
--- a/server/agent/queue.ts
+++ b/server/agent/queue.ts
@@ -29,11 +29,31 @@ export class AsyncQueue<T> {
   close(): void {
     if (this.closed) return
     this.closed = true
-    if (this.waiting) {
-      const resolve = this.waiting
-      this.waiting = null
-      resolve({ value: undefined as never, done: true })
-    }
+    this.release()
+  }
+
+  /**
+   * Le consommateur est parti, mais la file continue.
+   *
+   * C'est le cas quand la boucle du SDK meurt : elle ne referme pas l'itérateur
+   * qu'elle tenait, et il restait donc inscrit comme destinataire du prochain
+   * `push`. Le prompt de la relance lui était remis, dans un générateur que plus
+   * personne ne tirait — le message ne partait jamais et la session restait « au
+   * travail » pour toujours. Le dénouer rend la place au consommateur suivant,
+   * et ce qui arrive ensuite l'attend dans le tableau.
+   *
+   * À la différence de `close`, la file reste ouverte : c'est tout l'objet.
+   */
+  abandon(): void {
+    this.release()
+  }
+
+  /** Dénoue l'attente en cours, s'il y en a une. */
+  private release(): void {
+    if (!this.waiting) return
+    const resolve = this.waiting
+    this.waiting = null
+    resolve({ value: undefined as never, done: true })
   }
 
   async *[Symbol.asyncIterator](): AsyncGenerator<T> {
diff --git a/server/agent/runner.ts b/server/agent/runner.ts
index 4978f13..b572add 100644
--- a/server/agent/runner.ts
+++ b/server/agent/runner.ts
@@ -167,6 +167,14 @@ export class SessionRunner {
   /** Où en est la lecture du transcript, en octets. Voir `readShellEnds`. */
   private transcriptAt = 0
   private readonly queue = new AsyncQueue<SDKUserMessage>()
+  /**
+   * Combien de fois la boucle a démarré.
+   *
+   * Une seule, en régime ordinaire. Au-delà, c'est que la précédente est morte
+   * et qu'un tour l'a relancée — ce qui ne se devine pas à l'écran, d'où la
+   * ligne que `run()` écrit à partir de la deuxième.
+   */
+  private runs = 0
   private readonly subscribers = new Set<(upsert: AgentUpsert) => void>()
   private query: Query | null = null
   private stopped = false
@@ -597,7 +605,17 @@ export class SessionRunner {
    * `Query` est donc déjà là.
    */
   private ensureQuery(): void {
-    if (!this.query && !this.stopped) void this.run()
+    if (this.query || this.stopped) return
+    // `run()` capte tout ce qui vient du flux, mais pas ce que `query()` lève en
+    // montant : options refusées, serveur MCP mal formé. Sans ce `catch`, ce
+    // rejet-là n'avait pas de destinataire — la session restait « au travail »
+    // sans qu'aucun message ne vienne jamais.
+    void this.run().catch((e: unknown) => {
+      const message = e instanceof Error ? e.message : String(e)
+      this.emit(this.translator.appendSystem(t('agent.sessionEnded', { message }), 'error'))
+      this.log(message, e)
+      this.setStatus('failed', message)
+    })
   }
 
   /**
@@ -824,6 +842,19 @@ export class SessionRunner {
   }
 
   private async run(): Promise<void> {
+    this.runs += 1
+    // Une boucle qui repart après une mort ne doit pas repartir à vide. Le
+    // `resume` d'origine ne vaut que pour le premier démarrage : ensuite c'est
+    // l'identifiant que la session s'est vu attribuer qui fait foi, sans quoi
+    // une session née sans reprise recommençait une conversation neuve — même
+    // fil à l'écran, aucun souvenir derrière.
+    const reprise = this.session.sessionId || this.resume
+    if (this.runs > 1) {
+      // Le dire : une reprise silencieuse serait pire que la panne, puisque
+      // rien ne distinguerait à l'écran un contexte retrouvé d'un contexte perdu.
+      this.emit(this.translator.appendSystem(t(reprise ? 'agent.relaunched' : 'agent.relaunchedFresh')))
+    }
+
     this.query = query({
       prompt: this.queue,
       options: {
@@ -834,7 +865,7 @@ export class SessionRunner {
         includePartialMessages: true,
         permissionMode: this.session.permissionMode as never,
         ...(this.session.model ? { model: this.session.model } : {}),
-        ...(this.resume ? { resume: this.resume } : {}),
+        ...(reprise ? { resume: reprise } : {}),
         // On exécute nous-mêmes les questions à l'utilisateur : voir `ask.ts`.
         mcpServers: { atelier: createAskServer((questions) => this.askHuman(questions)) },
         toolAliases: { AskUserQuestion: ASK_TOOL },
@@ -862,6 +893,10 @@ export class SessionRunner {
       this.setStatus('failed', message)
     } finally {
       this.query = null
+      // Le SDK ne referme pas la file qu'il tenait : sans cela, son itérateur
+      // resterait inscrit comme destinataire du prochain `push`, et le prompt
+      // d'une relance partirait dans un générateur que plus personne ne tire.
+      this.queue.abandon()
     }
   }
 
diff --git a/server/i18n/en.ts b/server/i18n/en.ts
index 4c5095d..9027a59 100644
--- a/server/i18n/en.ts
+++ b/server/i18n/en.ts
@@ -64,6 +64,8 @@ const en: Catalog = {
     deniedFromAtelier: 'Denied from the Workshop.',
     sessionEnded: 'The session stopped: {message}',
     streamClosed: 'The stream closed on its own. I no longer have a session running; you can resume it.',
+    relaunched: 'I restarted the session on the previous exchange.',
+    relaunchedFresh: 'I restarted the session, but without its context: it had no identifier to resume yet.',
     cleared: 'I am opening a new session. The context is empty; the previous exchange stays on disk.',
     clearedByCommand: 'I am opening a new session: /clear emptied the context. The previous exchange stays on disk.',
     pickerUnavailable: 'No folder picker available on {platform}.',
diff --git a/server/i18n/fr.ts b/server/i18n/fr.ts
index 9e2f69b..3650970 100644
--- a/server/i18n/fr.ts
+++ b/server/i18n/fr.ts
@@ -80,6 +80,15 @@ export default {
      * flux s'est refermé, la reprise reste possible.
      */
     streamClosed: "Le flux s'est refermé de lui-même. Je n'ai plus de session en cours ; vous pouvez la reprendre.",
+    /**
+     * La boucle repart après une mort, et il faut dire dans quel état.
+     *
+     * Une reprise silencieuse serait pire que la panne : rien ne distinguerait
+     * à l'écran un contexte retrouvé d'un contexte perdu, et le fil affiché
+     * laisserait croire au second que l'agent se souvient du premier.
+     */
+    relaunched: "J'ai relancé la session sur l'échange précédent.",
+    relaunchedFresh: "J'ai relancé la session, mais sans son contexte : elle n'avait pas encore d'identifiant à reprendre.",
     /** Le fil vient d'être vidé : ces deux lignes sont tout ce qui reste à l'écran. */
     cleared: "J'ouvre une nouvelle session. Le contexte est vide ; l'échange précédent reste sur disque.",
     clearedByCommand: "J'ouvre une nouvelle session : /clear a vidé le contexte. L'échange précédent reste sur disque.",
diff --git a/test/agent-queue.test.ts b/test/agent-queue.test.ts
new file mode 100644
index 0000000..942c790
--- /dev/null
+++ b/test/agent-queue.test.ts
@@ -0,0 +1,99 @@
+// La file d'entrée de l'Atelier, et ce qu'elle fait d'un consommateur parti.
+//
+// Le cas qui a motivé ces tests : une session qui meurt puis repart ouvre un
+// second `for await` sur la même file. Le premier, suspendu sur sa promesse,
+// restait inscrit comme destinataire — le prompt de la relance lui était remis,
+// dans un générateur que plus personne ne tirait. Le message ne partait jamais
+// et la session restait « au travail » pour toujours.
+
+import { describe, expect, it } from 'vitest'
+import { AsyncQueue } from '../server/agent/queue.ts'
+
+/** Laisse tourner la boucle d'événements : les `await` en vol se posent. */
+function tick(): Promise<void> {
+  return new Promise((resolve) => setImmediate(resolve))
+}
+
+/** Consomme la file en arrière-plan et note ce qui lui parvient. */
+function drain<T>(queue: AsyncQueue<T>): { seen: T[]; done: Promise<void> } {
+  const seen: T[] = []
+  const done = (async () => {
+    for await (const item of queue) seen.push(item)
+  })()
+  return { seen, done }
+}
+
+describe('la file d’entrée', () => {
+  it('remet ce qui était déjà là, puis ce qui arrive', async () => {
+    const queue = new AsyncQueue<string>()
+    queue.push('un')
+    const { seen } = drain(queue)
+    await tick()
+    queue.push('deux')
+    await tick()
+    expect(seen).toEqual(['un', 'deux'])
+  })
+
+  it('rend la main au consommateur quand la file se ferme', async () => {
+    const queue = new AsyncQueue<string>()
+    const { seen, done } = drain(queue)
+    await tick()
+    queue.close()
+    await done
+    expect(seen).toEqual([])
+  })
+
+  it('ne remet plus rien à un consommateur abandonné', async () => {
+    const queue = new AsyncQueue<string>()
+    const premier = drain(queue)
+    await tick()
+
+    // La boucle du SDK est morte : elle ne referme pas forcément l'itérateur
+    // qu'elle tenait, c'est le runner qui le déclare parti.
+    queue.abandon()
+    await premier.done
+
+    queue.push('après la mort')
+    await tick()
+    expect(premier.seen).toEqual([])
+  })
+
+  it('remet au consommateur suivant le message poussé avant lui', async () => {
+    const queue = new AsyncQueue<string>()
+    const premier = drain(queue)
+    await tick()
+    queue.abandon()
+    await premier.done
+
+    // L'ordre est celui de `send()` : on pousse le prompt, puis on relance la
+    // boucle. C'est exactement là que le message se perdait.
+    queue.push('le tour de la reprise')
+    const second = drain(queue)
+    await tick()
+
+    expect(premier.seen).toEqual([])
+    expect(second.seen).toEqual(['le tour de la reprise'])
+  })
+
+  it('reste ouverte après un abandon, là où `close` la ferme', async () => {
+    const queue = new AsyncQueue<string>()
+    const premier = drain(queue)
+    await tick()
+    queue.abandon()
+    await premier.done
+
+    queue.push('encore vivante')
+    const second = drain(queue)
+    await tick()
+    expect(second.seen).toEqual(['encore vivante'])
+  })
+
+  it('n’accepte plus rien une fois fermée', async () => {
+    const queue = new AsyncQueue<string>()
+    queue.close()
+    queue.push('trop tard')
+    const { seen, done } = drain(queue)
+    await done
+    expect(seen).toEqual([])
+  })
+})

From 6bc379b90f14496a3cbd6cac7e9c0f48a5f12377 Mon Sep 17 00:00:00 2001
From: Shaenn <22753401+Shaenn@users.noreply.github.com>
Date: Thu, 3 Sep 2026 01:36:27 +0200
Subject: [PATCH 5/9] =?UTF-8?q?Une=20demande=20en=20vol=20survit=20=C3=A0?=
 =?UTF-8?q?=20une=20coupure,=20et=20une=20session=20disparue=20se=20dit?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Le `snapshot` portait le fil, l'activité et les shells, mais pas ce qui attend
une réponse. Une demande de permission émise pendant une coupure du flux ne
revenait donc jamais : le bandeau n'apparaissait pas et l'agent restait suspendu
jusqu'au refus du garde-fou, un quart d'heure plus tard. Dans l'autre sens, une
demande réglée pendant la coupure laissait un bandeau fantôme dont le clic ne
pouvait plus rien dénouer. Elles font partie de l'état, au même titre que le
reste, et c'est la liste entière qui remplace celle du client — vide comprise.

Les deux constructions du `snapshot` n'en font plus qu'une : elles divergeaient
déjà, l'une portant un commentaire que l'autre n'avait pas.

`stop()` n'annonçait rien : la socket restait ouverte, son battement continuait,
et l'écran se figeait sur le dernier statut reçu. Il le dit maintenant — pour un
arrêt demandé d'un autre onglet, et pour l'extinction du serveur.

Le balayeur, lui, ne peut pas être annoncé : il ne ramasse que ce que plus
personne ne regarde, donc sans abonné à qui parler. C'est au front de constater,
et il le fait depuis le lien perdu — il va voir toutes les cinq secondes si la
session existe encore, et bascule sur « Reprendre » quand elle a disparu. Un
appel qui échoue ne conclut rien : le BFF est peut-être en train de redémarrer.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 server/agent/runner.ts            | 74 ++++++++++++++++++++++++-------
 shared/agent.ts                   | 14 ++++++
 src/composables/useLiveSession.ts |  6 +++
 src/pages/AtelierPage.vue         | 53 ++++++++++++++++++++++
 4 files changed, 131 insertions(+), 16 deletions(-)

diff --git a/server/agent/runner.ts b/server/agent/runner.ts
index b572add..038ae9c 100644
--- a/server/agent/runner.ts
+++ b/server/agent/runner.ts
@@ -15,6 +15,7 @@ import type {
   AgentStatus,
   AgentUpsert,
   AskQuestion,
+  AskRequest,
   PermissionAnswer,
   PermissionRequest,
   PromptAttachment,
@@ -213,6 +214,17 @@ export class SessionRunner {
   private readonly permissions = new Map<string, PendingAnswer<PermissionResult>>()
   /** Les questions en vol. Même mécanique, autre canal : rien à autoriser ici. */
   private readonly asks = new Map<string, PendingAnswer<string>>()
+  /**
+   * Ce qu'une demande en vol dit à l'écran, gardé le temps qu'elle vive.
+   *
+   * La promesse suspend le SDK ; ces deux cartes-là servent à la **rejouer** —
+   * un onglet qui s'abonne au milieu d'une attente doit voir le bandeau, sans
+   * quoi la demande reste invisible et l'agent suspendu jusqu'au garde-fou.
+   * Même motif que `suggestions` et `permissionInputs` : une carte parallèle,
+   * vidée dans le même `finally`.
+   */
+  private readonly permissionRequests = new Map<string, PermissionRequest>()
+  private readonly askRequests = new Map<string, AskRequest>()
   /**
    * Les règles suggérées par le SDK pour la demande en cours, gardées le temps
    * qu'un humain choisisse « toujours autoriser ». Elles ne se devinent pas :
@@ -261,8 +273,16 @@ export class SessionRunner {
    * un onglet ouvert au milieu d'un tour voit donc la même chose qu'un onglet
    * présent depuis le début.
    */
-  subscribe(send: (upsert: AgentUpsert) => void): () => void {
-    send({
+  /**
+   * Tout l'état d'une session, en un message.
+   *
+   * Il part à chaque abonnement, et à chaque fois que le fil change d'identité
+   * (`/clear`). Rien ne s'y ajoute : les listes qu'il porte **remplacent** celles
+   * du client, vides comprises — c'est ce qui rattrape une coupure sans que le
+   * front ait à tenir un curseur.
+   */
+  private snapshot(): AgentUpsert {
+    return {
       kind: 'snapshot',
       session: this.session,
       events: this.translator.events,
@@ -272,7 +292,18 @@ export class SessionRunner {
       // Les shells encore plus : celui qui tient un port a pu partir il y a une
       // heure, bien avant que cet onglet n'existe.
       shells: this.shells.snapshot(),
-    })
+      // Ce qui attend un humain, au même titre. Une demande émise pendant une
+      // coupure du flux ne revenait jamais : le bandeau n'apparaissait pas et
+      // l'agent restait suspendu jusqu'au refus du garde-fou. Dans l'autre sens,
+      // une demande réglée pendant la coupure laissait un bandeau fantôme que
+      // plus aucun clic ne pouvait dénouer.
+      permissions: [...this.permissionRequests.values()],
+      asks: [...this.askRequests.values()],
+    }
+  }
+
+  subscribe(send: (upsert: AgentUpsert) => void): () => void {
+    send(this.snapshot())
     this.touchedAt = Date.now()
     this.subscribers.add(send)
     return () => {
@@ -388,17 +419,10 @@ export class SessionRunner {
     // qu'on vient d'envoyer.
     const byClear = /^\/clear\b/.test(this.lastPrompt)
     this.translator.appendSystem(t(byClear ? 'agent.clearedByCommand' : 'agent.cleared'), 'warn')
-    this.emit([
-      {
-        kind: 'snapshot',
-        session: this.session,
-        events: this.translator.events,
-        activity: this.activity.snapshot(),
-        // La conversation repart à vide, pas la machine : un serveur lancé avant
-        // le `/clear` tient toujours son port, et reste donc à l'écran.
-        shells: this.shells.snapshot(),
-      },
-    ])
+    // La conversation repart à vide, pas la machine : un serveur lancé avant le
+    // `/clear` tient toujours son port, et une demande en vol attend toujours sa
+    // réponse. Le fil seul s'efface.
+    this.emit([this.snapshot()])
   }
 
   /**
@@ -686,6 +710,17 @@ export class SessionRunner {
   stop(grace = STOP_GRACE_MS): void {
     if (this.stopped) return
     this.stopped = true
+    // Le dire aux onglets qui regardent encore. Sans cela l'arrêt ne se voyait
+    // nulle part : la socket restait ouverte, son battement continuait, et
+    // l'écran se figeait sur le dernier statut reçu sans jamais l'admettre.
+    // C'est le cas d'un arrêt demandé depuis un autre onglet, et celui de
+    // l'extinction du serveur. Le balayeur, lui, ne ramasse que ce que plus
+    // personne ne regarde : ce message-là n'aurait pas d'auditeur, et c'est le
+    // front qui doit constater la disparition.
+    if (this.session.status !== 'ended' && this.session.status !== 'failed') {
+      this.emit(this.translator.appendSystem(t('agent.sessionStopped')))
+      this.setStatus('ended')
+    }
     if (this.shellPoll) {
       clearInterval(this.shellPoll)
       this.shellPoll = null
@@ -749,6 +784,7 @@ export class SessionRunner {
       return { behavior: 'deny', message: t('agent.permissionTimeout') }
     })
     this.permissions.set(id, pending)
+    this.permissionRequests.set(id, request)
     this.emit([{ kind: 'permission-request', request }])
 
     // Une interruption pendant l'attente doit libérer le tour, pas le figer.
@@ -769,6 +805,7 @@ export class SessionRunner {
       return await pending.promise
     } finally {
       this.permissions.delete(id)
+      this.permissionRequests.delete(id)
       this.suggestions.delete(id)
       this.permissionInputs.delete(id)
     }
@@ -805,9 +842,14 @@ export class SessionRunner {
       this.emit([{ kind: 'ask-settled', id }])
       return NO_ANSWER
     })
+    const request: AskRequest = { id, questions, askedAt: Date.now() }
     this.asks.set(id, pending)
-    this.emit([{ kind: 'ask-request', request: { id, questions, askedAt: Date.now() } }])
-    return pending.promise.finally(() => this.asks.delete(id))
+    this.askRequests.set(id, request)
+    this.emit([{ kind: 'ask-request', request }])
+    return pending.promise.finally(() => {
+      this.asks.delete(id)
+      this.askRequests.delete(id)
+    })
   }
 
   /** Répond à une question. Rend `false` si elle n'est plus en vol. */
diff --git a/shared/agent.ts b/shared/agent.ts
index 7366749..1ea2ebe 100644
--- a/shared/agent.ts
+++ b/shared/agent.ts
@@ -237,6 +237,20 @@ export type AgentUpsert =
       events: TranscriptEvent[]
       activity: AgentActivity
       shells: BackgroundShell[]
+      /**
+       * Ce qui attend un humain, et qui n'était pas rejoué.
+       *
+       * Une demande émise pendant une coupure du flux ne revenait jamais : le
+       * bandeau n'apparaissait pas, et l'agent restait suspendu jusqu'au refus
+       * du garde-fou, un quart d'heure plus tard. Dans l'autre sens, une demande
+       * réglée pendant la coupure laissait un bandeau fantôme, dont le clic ne
+       * pouvait plus rien dénouer.
+       *
+       * Elles appartiennent donc à l'état au même titre que l'activité : c'est
+       * la liste entière qui remplace celle du client, vide comprise.
+       */
+      permissions: PermissionRequest[]
+      asks: AskRequest[]
     }
   | { kind: 'session'; session: AgentSession }
   | { kind: 'append-event'; event: TranscriptEvent }
diff --git a/src/composables/useLiveSession.ts b/src/composables/useLiveSession.ts
index 0a7bf68..ed144ad 100644
--- a/src/composables/useLiveSession.ts
+++ b/src/composables/useLiveSession.ts
@@ -97,6 +97,12 @@ export function useLiveSession() {
         events.value = upsert.events
         activity.value = upsert.activity
         shells.value = upsert.shells
+        // Le serveur dit ce qui attend vraiment une réponse — vide compris.
+        // Sans ces deux lignes, une demande émise pendant une coupure ne
+        // revenait pas, et une demande réglée pendant la coupure laissait un
+        // bandeau que plus aucun clic ne pouvait dénouer.
+        permissions.value = upsert.permissions
+        asks.value = upsert.asks
         reindex()
         return
 
diff --git a/src/pages/AtelierPage.vue b/src/pages/AtelierPage.vue
index 61fbccd..0153212 100644
--- a/src/pages/AtelierPage.vue
+++ b/src/pages/AtelierPage.vue
@@ -902,6 +902,59 @@
     }
   }
 
+  /**
+   * Le pas auquel on va voir si une session dont on a perdu le fil existe encore.
+   *
+   * `EventSource` retente seul toutes les trois secondes environ ; interroger
+   * plus vite qu'elle ne se reconnecte ferait conclure à une disparition là où
+   * il n'y avait qu'un hoquet.
+   */
+  const GONE_POLL_MS = 5000
+  let gonePoll: ReturnType<typeof setInterval> | null = null
+
+  /**
+   * La session a-t-elle disparu, ou est-ce seulement le lien ?
+   *
+   * `reopenFromUrl` posait déjà la question, mais au montage seulement : une
+   * session ramassée par le balayeur pendant qu'on la regardait laissait donc un
+   * fil figé, sur lequel l'`EventSource` se reconnectait indéfiniment contre un
+   * 404. Le serveur ne peut pas nous le dire — le balayeur ne ramasse que ce que
+   * plus personne ne regarde, et à ce moment-là il n'y a plus d'abonné à qui
+   * l'annoncer. C'est donc ici qu'on va voir.
+   *
+   * Un appel qui échoue ne conclut rien : le BFF est peut-être en train de
+   * redémarrer, et le déclarer disparu couperait un fil qui revient.
+   */
+  async function checkStillThere(): Promise<void> {
+    const run = session.value?.runId
+    if (!run) return
+    let sessions: AgentSession[]
+    try {
+      ;({ sessions } = await listAgentSessions())
+    } catch {
+      return
+    }
+    if (sessions.some((s) => s.runId === run)) return
+    const slug = session.value?.slug ?? ''
+    const id = session.value?.sessionId ?? ''
+    detach()
+    session.value = null
+    gone.value = { session: id, slug }
+  }
+
+  /** On ne va voir que tant que le lien manque, et jamais avant. */
+  watch(lost, (perdu) => {
+    if (gonePoll) {
+      clearInterval(gonePoll)
+      gonePoll = null
+    }
+    if (perdu) gonePoll = setInterval(() => void checkStillThere(), GONE_POLL_MS)
+  })
+
+  onUnmounted(() => {
+    if (gonePoll) clearInterval(gonePoll)
+  })
+
   /** Refermer l'avis, et nettoyer l'adresse : elle ne désigne plus rien. */
   function dismissGone(): void {
     gone.value = null

From 6a810a9d26705166692a4898d7afa4751c941002 Mon Sep 17 00:00:00 2001
From: Shaenn <22753401+Shaenn@users.noreply.github.com>
Date: Thu, 3 Sep 2026 01:39:12 +0200
Subject: [PATCH 6/9] =?UTF-8?q?=C2=AB=20Elle=20travaille=20=C2=BB=20ne=20p?=
 =?UTF-8?q?rot=C3=A8ge=20plus=20une=20session=20dont=20le=20processus=20s'?=
 =?UTF-8?q?est=20tu?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Le balayeur ne ramasse jamais une session en cours de tour, et c'est juste : un
`Bash` de vingt minutes n'est pas un abandon. Mais ce statut protégeait sans
réserve, si bien qu'une session figée le gardait pour toujours — elle échappait
au balayeur *et* occupait une des six places du parc, sans qu'aucun geste ne
puisse la libérer.

Le travail se prouve désormais par le pouls du SDK : n'importe quel message
suffit, même ceux dont on ne fait rien. Une heure de silence lève la protection,
délibérément le double du délai d'inactivité — un garde-fou ne peut que faire
taire, jamais inventer une panne, et un tour vivant parle bien avant. Le
ramassage exige toujours les deux silences à la fois, celui du SDK et celui de
l'humain, et un onglet ouvert reste la raison de vivre la plus forte.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 server/agent/runner.ts          | 40 +++++++++++++++++++++++++++---
 test/session-guardrails.test.ts | 43 +++++++++++++++++++++++++++++++++
 2 files changed, 80 insertions(+), 3 deletions(-)

diff --git a/server/agent/runner.ts b/server/agent/runner.ts
index 038ae9c..1ecfaa7 100644
--- a/server/agent/runner.ts
+++ b/server/agent/runner.ts
@@ -132,6 +132,24 @@ const ACTIVITY_STEP_MS = 250
  */
 const SHELL_POLL_MS = 2_000
 
+/**
+ * Au bout de combien de silence du SDK une session « au travail » cesse d'être
+ * protégée par son travail.
+ *
+ * Le balayeur ne ramasse jamais une session en cours de tour : un `Bash` de vingt
+ * minutes n'est pas un abandon. Mais une session dont le processus s'est figé
+ * garde ce statut pour toujours — elle échappait donc au balayeur *et* occupait
+ * une des six places du parc, sans qu'aucun geste ne puisse la libérer.
+ *
+ * Une heure, et c'est délibérément le double du délai d'inactivité : ce garde-fou
+ * ne peut que faire taire, jamais inventer une panne. Un tour vivant parle bien
+ * avant — le SDK émet ses fragments, ses relevés d'outil, ses pings de
+ * raisonnement. Une heure sans un seul message n'est pas un tour long, c'est un
+ * mort. Le ramassage exige de toute façon les deux silences à la fois : celui du
+ * SDK et celui de l'humain.
+ */
+export const SDK_SILENCE_MS = 60 * 60_000
+
 export class SessionRunner {
   readonly session: AgentSession
 
@@ -176,6 +194,14 @@ export class SessionRunner {
    * ligne que `run()` écrit à partir de la deuxième.
    */
   private runs = 0
+  /**
+   * Le dernier message venu du SDK — le pouls de la session.
+   *
+   * À distinguer de `touchedAt`, qui ne compte que les gestes humains : celui-ci
+   * dit si le processus respire encore. Il naît avec la session plutôt qu'à
+   * zéro, sans quoi une session jamais démarrée passerait pour figée.
+   */
+  private lastMessageAt = Date.now()
   private readonly subscribers = new Set<(upsert: AgentUpsert) => void>()
   private query: Query | null = null
   private stopped = false
@@ -332,8 +358,9 @@ export class SessionRunner {
    *
    * Trois conditions, et il les faut toutes. Personne ne regarde. Elle ne
    * travaille pas — un tour de vingt minutes n'est pas un abandon, et le CLI
-   * n'écouterait de toute façon pas qu'on lui ferme son entrée. Et le dernier
-   * geste humain remonte à plus loin que le délai.
+   * n'écouterait de toute façon pas qu'on lui ferme son entrée ; encore
+   * faut-il que ce travail soit réel, ce que seul le pouls du SDK dit. Et le
+   * dernier geste humain remonte à plus loin que le délai.
    *
    * Un flux ouvert protège **sans réserve**, et c'est un choix. On sait qu'il ne
    * prouve pas qu'un humain regarde : le navigateur gèle un onglet d'arrière-plan
@@ -350,7 +377,11 @@ export class SessionRunner {
   expired(ttlMs: number): boolean {
     if (this.stopped) return false
     if (this.subscribers.size > 0) return false
-    if (this.session.status === 'working') return false
+    // « Elle travaille » protège tant que le processus le prouve. Sans ce
+    // second membre, une session figée gardait ce statut pour toujours : elle
+    // échappait au balayeur *et* occupait une des six places du parc, sans
+    // qu'aucun geste ne puisse la libérer. Voir `SDK_SILENCE_MS`.
+    if (this.session.status === 'working' && Date.now() - this.lastMessageAt <= SDK_SILENCE_MS) return false
     return Date.now() - this.touchedAt > ttlMs
   }
 
@@ -986,6 +1017,9 @@ export class SessionRunner {
   }
 
   private consume(message: Rec): void {
+    // Le pouls, avant toute lecture : n'importe quel message prouve que le
+    // processus respire, même ceux dont on ne fait rien.
+    this.lastMessageAt = Date.now()
     // Avant tout dispatch : la plupart des messages qui disent où en est l'agent
     // ne produisent aucun événement de timeline, et sortaient donc par le
     // `default` sans laisser de trace.
diff --git a/test/session-guardrails.test.ts b/test/session-guardrails.test.ts
index 346ec3d..6aa1420 100644
--- a/test/session-guardrails.test.ts
+++ b/test/session-guardrails.test.ts
@@ -10,11 +10,17 @@
 // personne ne regarde, et surtout qu'il ne ramasse *que* cela — un tour de vingt
 // minutes et un onglet ouvert sont deux raisons de vivre.
 //
+// La première de ces deux raisons a une limite, et elle s'éprouve ici aussi : un
+// tour ne protège qu'aussi longtemps que le processus le prouve. Sans cela, une
+// session figée gardait son statut « au travail » pour toujours et occupait une
+// place du parc que plus aucun geste ne pouvait libérer.
+//
 // Aucun test n'envoie de tour : le runner ne lance son processus qu'au premier
 // `send()`, et ces bornes se vérifient toutes avant.
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { atCapacity, countSessions, createRunner, IDLE_TTL_MS, MAX_SESSIONS, stopAll, sweep } from '../server/agent/registry.ts'
+import { SDK_SILENCE_MS } from '../server/agent/runner.ts'
 
 const CWD = import.meta.dirname
 
@@ -93,6 +99,43 @@ describe('balayeur d’inactivité', () => {
     expect(countSessions()).toBe(1)
   })
 
+  it('ramasse celle qui prétend travailler alors que son processus s’est tu', () => {
+    // Le cas qui manquait : ce statut protégeait sans réserve, donc une session
+    // figée échappait au balayeur *et* occupait une des six places du parc,
+    // sans qu'aucun geste ne puisse la libérer.
+    const figée = open()
+    figée.session.status = 'working'
+
+    laisserPasser(SDK_SILENCE_MS + 1)
+
+    expect(sweep()).toEqual([figée.session.runId])
+    expect(countSessions()).toBe(0)
+  })
+
+  it('ne la ramasse pas tant que le silence n’a pas duré une heure', () => {
+    const occupée = open()
+    occupée.session.status = 'working'
+
+    laisserPasser(SDK_SILENCE_MS - 1000)
+
+    expect(sweep()).toEqual([])
+    expect(countSessions()).toBe(1)
+  })
+
+  it('garde la session figée qu’un onglet regarde encore', () => {
+    // Le silence du SDK lève la protection du travail, pas celle du flux : un
+    // écran ouvert reste la raison de vivre la plus forte, et couper dessous
+    // serait exactement ce que le balayeur s'interdit.
+    const regardée = open()
+    regardée.session.status = 'working'
+    regardée.subscribe(() => {})
+
+    laisserPasser(SDK_SILENCE_MS * 2)
+
+    expect(sweep()).toEqual([])
+    expect(countSessions()).toBe(1)
+  })
+
   it('repart de zéro quand le dernier onglet se ferme, pas quand il s’est ouvert', () => {
     const runner = open()
     const partir = runner.subscribe(() => {})

From 993342528a136b3ca3e8772f9ae48586e1de3991 Mon Sep 17 00:00:00 2001
From: Shaenn <22753401+Shaenn@users.noreply.github.com>
Date: Thu, 3 Sep 2026 01:41:00 +0200
Subject: [PATCH 7/9] =?UTF-8?q?Une=20compaction=20ne=20s'affiche=20plus=20?=
 =?UTF-8?q?deux=20fois=20pendant=20que=20le=20fichier=20s'=C3=A9crit?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Le complément de la couture — ce que le direct a vu après le dernier tour humain
et que le fichier n'a pas encore — se faisait par la seule longueur, et la
longueur mélangeait deux familles. Le fichier ne s'écrit pas dans l'ordre du
direct : la frontière de compaction y précède la ligne `/compact`. Comme il est
relu toutes les deux secondes et demie pendant une action, on le surprenait à
mi-chemin, une commande de moins que le direct — et le décalage laissait passer
la frontière du direct par-dessus celle du fichier.

Le fil montrait donc deux compactions là où la session n'en avait vécu qu'une,
et perdait au passage la ligne de commande qui l'avait provoquée.

Chaque famille se complète maintenant selon son propre critère : une compaction
se reconnaît à son `uuid`, que les deux sources lui donnent identique — c'est ce
dont `diskCaughtUp` se servait déjà — et une commande `/`, qui n'a d'identité
commune ni par sa clé ni par son horloge, se compte.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/components/replay/seam.ts | 21 ++++++++++++++++++++-
 test/atelier-seam.test.ts     | 24 ++++++++++++++++++++++++
 2 files changed, 44 insertions(+), 1 deletion(-)

diff --git a/src/components/replay/seam.ts b/src/components/replay/seam.ts
index 1f73804..cf49474 100644
--- a/src/components/replay/seam.ts
+++ b/src/components/replay/seam.ts
@@ -69,7 +69,26 @@ function trailingCommands(events: readonly TranscriptEvent[]): TranscriptEvent[]
  * et ne complète plus rien dès que le disque a rattrapé.
  */
 function pendingCommands(disk: readonly TranscriptEvent[], live: readonly TranscriptEvent[]): TranscriptEvent[] {
-  return trailingCommands(live).slice(trailingCommands(disk).length)
+  const ecrites = trailingCommands(disk)
+  // Une compaction se reconnaît, une commande se compte. Les deux sources
+  // donnent le même `uuid` à une frontière de compaction — c'est ce que
+  // `diskCaughtUp` emploie déjà — alors qu'une commande `/` n'a d'identité
+  // commune ni par sa clé ni par son horloge.
+  const posees = new Set(ecrites.filter((e) => e.kind === 'compaction').map((e) => e.uuid))
+  const comptees = ecrites.filter((e) => e.kind !== 'compaction').length
+
+  // Le complément se faisait par la seule longueur, et la longueur mélangeait
+  // les deux familles. Le fichier s'écrit dans un ordre qui n'est pas celui du
+  // direct : la frontière y précède la ligne `/compact`. On surprenait donc le
+  // disque à mi-chemin — une commande de moins que le direct — et le décalage
+  // laissait passer la frontière du direct par-dessus celle du fichier. Le fil
+  // affichait alors deux compactions là où la session n'en avait vécu qu'une.
+  let vues = 0
+  return trailingCommands(live).filter((e) => {
+    if (e.kind === 'compaction') return !posees.has(e.uuid)
+    vues += 1
+    return vues > comptees
+  })
 }
 
 /**
diff --git a/test/atelier-seam.test.ts b/test/atelier-seam.test.ts
index fc7b747..b2dd9d5 100644
--- a/test/atelier-seam.test.ts
+++ b/test/atelier-seam.test.ts
@@ -88,6 +88,30 @@ describe('la couture du fil', () => {
     expect(stitch(disk, [...disk, compact, mark], 1)).toEqual([...disk, compact, mark])
   })
 
+  it('ne la montre pas deux fois pendant que le fichier s’écrit', () => {
+    // Le fichier est relu toutes les deux secondes et demie pendant une action :
+    // on le surprend donc à mi-chemin, la frontière écrite mais pas encore la
+    // ligne de commande qui l'a provoquée. Compter les commandes de part et
+    // d'autre donnait alors un de moins côté disque, et le complément laissait
+    // passer la frontière du direct par-dessus celle du fichier.
+    const compact = command('/compact')
+    const mark = boundary('c1')
+    const written = [human('un'), answer('un'), boundary('c1')]
+    const live = [human('un'), answer('un'), compact, mark]
+    expect(stitch(written, live, 1)).toEqual([...written, compact])
+  })
+
+  it('complète la commande écrite de la frontière qui lui manque', () => {
+    // L'autre moitié du même chemin : selon le moment où l'on relit, c'est la
+    // commande qui est là et la frontière qui manque. Chaque famille se
+    // complète selon son propre critère — l'uuid pour l'une, le compte pour
+    // l'autre.
+    const compact = command('/compact')
+    const mark = boundary('c1')
+    const written = [human('un'), answer('un'), command('/compact')]
+    expect(stitch(written, [human('un'), answer('un'), compact, mark], 1)).toEqual([...written, mark])
+  })
+
   it('ne la montre pas deux fois une fois le fichier rattrapé', () => {
     const compact = command('/compact')
     const mark = boundary('c1')

From 4d0fda530db8c2aaa0b2354c50e57f4de815592e Mon Sep 17 00:00:00 2001
From: Shaenn <22753401+Shaenn@users.noreply.github.com>
Date: Thu, 3 Sep 2026 01:59:49 +0200
Subject: [PATCH 8/9] =?UTF-8?q?L'avis=20d'une=20session=20disparue=20ne=20?=
 =?UTF-8?q?s'efface=20plus=20lui-m=C3=AAme?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Constater qu'une session n'existe plus nettoie l'adresse, et ce nettoyage est
exactement ce que le veilleur d'adresse lit pour écarter un avis périmé. L'avis
s'effaçait donc à l'instant où on le posait, et l'écran d'ouverture revenait sans
un mot d'explication — vu à l'écran, pas dans le code.

Le drapeau ne vaut que pour cette navigation-là : celles que l'utilisateur fait
ensuite retrouvent le comportement d'origine, qui reste nécessaire.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/pages/AtelierPage.vue | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/pages/AtelierPage.vue b/src/pages/AtelierPage.vue
index 0153212..1bc2a7c 100644
--- a/src/pages/AtelierPage.vue
+++ b/src/pages/AtelierPage.vue
@@ -867,9 +867,24 @@
    * route, même instance. L'avis « session plus ouverte » y survivait donc à
    * l'adresse qui l'avait causé, et s'affichait devant un écran d'ouverture vierge.
    */
+  /**
+   * La navigation qui *pose* l'avis ne doit pas l'effacer.
+   *
+   * Constater qu'une session a disparu nettoie l'adresse, et ce nettoyage est
+   * exactement ce que le veilleur ci-dessus lit pour écarter un avis périmé :
+   * l'avis s'effaçait donc lui-même, et l'écran d'ouverture revenait sans un mot
+   * d'explication. Le drapeau ne vaut que pour la navigation suivante — celles
+   * que l'utilisateur fait ensuite retrouvent le comportement d'origine.
+   */
+  let goneNavigation = false
+
   watch(
     () => route.query.run,
     (run) => {
+      if (goneNavigation) {
+        goneNavigation = false
+        return
+      }
       if (!run) gone.value = null
     },
   )
@@ -939,7 +954,11 @@
     const id = session.value?.sessionId ?? ''
     detach()
     session.value = null
+    // Le nettoyage d'adresse qui suit est le nôtre : il ne doit pas emporter
+    // l'avis qu'on vient de poser. Voir `goneNavigation`.
+    goneNavigation = true
     gone.value = { session: id, slug }
+    await router.replace({ name: 'atelier', query: {} })
   }
 
   /** On ne va voir que tant que le lien manque, et jamais avant. */

From 726345678d9282314e7d80d674ccbf9c56796637 Mon Sep 17 00:00:00 2001
From: Shaenn <22753401+Shaenn@users.noreply.github.com>
Date: Thu, 3 Sep 2026 02:06:38 +0200
Subject: [PATCH 9/9] Le verre des panneaux flottants avait perdu son flou au
 passage du build
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Les dialogues, menus et drawers se lisaient au travers : on distinguait la barre
de session et le fil derrière le lecteur de ressources.

La cause n'était pas dans la règle mais dans sa compilation. Le minifieur tient
`-webkit-backdrop-filter` et `backdrop-filter` pour équivalents et ne garde que
la dernière des deux : écrite en premier, la propriété standard disparaissait du
CSS livré, et il ne restait que le préfixe, que ce Chrome n'honore pas. Le fond
translucide à 86 % restait donc seul, sans le flou qui le rend opaque.

Le repli `@supports` ne rattrapait rien, et ne le pouvait pas : il teste le
support du navigateur, acquis depuis longtemps, pas la présence de la règle.

Inverser les deux lignes suffit. Vérifié dans le CSS livré, puis à l'écran :
`backdrop-filter` calculé vaut de nouveau `blur(40px)`.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/css/app.scss | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/css/app.scss b/src/css/app.scss
index f8b9937..bad418d 100644
--- a/src/css/app.scss
+++ b/src/css/app.scss
@@ -609,12 +609,21 @@ body.body--dark {
 // (0,2,0) supérieure à celle de `.surface-card` (0,1,0), donc le fond de verre
 // l'emporte sur le fond opaque de la primitive sans `!important` — et la carte
 // conserve l'arête lumineuse que `.surface-card` lui donne déjà.
+//
+// L'ordre des deux dernières lignes n'est pas indifférent, et il a coûté cher à
+// trouver : le minifieur tient le préfixe et la propriété standard pour
+// équivalents, et ne garde que **la dernière** des deux. Écrite en premier, la
+// standard disparaissait du CSS livré — le build ne portait plus que
+// `-webkit-backdrop-filter`, que ce Chrome n'honore pas. Les panneaux gardaient
+// donc leur fond translucide sans le flou qui le rend opaque, et l'on lisait la
+// page au travers. Le repli ci-dessous ne rattrapait rien : il teste le
+// *support* du navigateur, qui est acquis, pas la présence de la règle.
 .q-drawer,
 .q-menu,
 .q-dialog__inner > .q-card {
   background: var(--glass-bg);
-  backdrop-filter: blur(var(--glass-blur));
   -webkit-backdrop-filter: blur(var(--glass-blur));
+  backdrop-filter: blur(var(--glass-blur));
 }
 
 // Repli : sans `backdrop-filter`, un fond translucide laisserait lire le contenu