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 baa94ca..1ecfaa7 100644
--- a/server/agent/runner.ts
+++ b/server/agent/runner.ts
@@ -15,6 +15,7 @@ import type {
   AgentStatus,
   AgentUpsert,
   AskQuestion,
+  AskRequest,
   PermissionAnswer,
   PermissionRequest,
   PromptAttachment,
@@ -131,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
 
@@ -167,6 +186,22 @@ 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
+  /**
+   * 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
@@ -205,6 +240,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 :
@@ -253,8 +299,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,
@@ -264,7 +318,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 () => {
@@ -293,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
@@ -311,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
   }
 
@@ -380,17 +450,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()])
   }
 
   /**
@@ -597,7 +660,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)
+    })
   }
 
   /**
@@ -668,6 +741,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
@@ -731,6 +815,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.
@@ -751,6 +836,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)
     }
@@ -787,9 +873,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. */
@@ -804,7 +895,39 @@ 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.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: {
@@ -815,7 +938,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 },
@@ -827,13 +950,26 @@ 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
+      // 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()
     }
   }
 
@@ -881,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/server/i18n/en.ts b/server/i18n/en.ts
index b692d34..9027a59 100644
--- a/server/i18n/en.ts
+++ b/server/i18n/en.ts
@@ -63,6 +63,9 @@ 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.',
+    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 0460fa8..3650970 100644
--- a/server/i18n/fr.ts
+++ b/server/i18n/fr.ts
@@ -71,6 +71,24 @@ 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.",
+    /**
+     * 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/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/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;
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/src/composables/useLiveSession.ts b/src/composables/useLiveSession.ts
index 31b0340..ed144ad 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>()
@@ -86,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
 
@@ -150,7 +167,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 +255,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 +305,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 +322,7 @@ export function useLiveSession() {
     permissions,
     asks,
     connected,
+    lost,
     activity,
     commands,
     commandsLoading,
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
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..1bc2a7c 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,
@@ -859,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
     },
   )
@@ -894,6 +917,63 @@
     }
   }
 
+  /**
+   * 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
+    // 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. */
+  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
@@ -2126,6 +2206,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);
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([])
+  })
+})
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')
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', () => {
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(() => {})