From 804ca8669b1f37d58dfd1398b417499dc196a5c6 Mon Sep 17 00:00:00 2001
From: Chris0Jeky <jeky.tck@gmail.com>
Date: Sat, 5 Sep 2026 17:21:59 +0100
Subject: [PATCH 1/3] feat(inbox): let the row editor hand out and take back an
 unsaved draft

The Paper triage row editor now exposes `readDraft()`, which answers with the
unsaved correction only while the capture text has loaded and something
actually differs from it, and accepts a `restoredDraft` prop that it applies
once over the freshly re-read server values before announcing `restored`.

A getter rather than an emit on unmount: `close` fires on Cancel and on a
completed Save as well as on an involuntary close, so an unmount emit would
force the table to infer which kind of close it was. The table already knows
the one moment the close is involuntary and can read the draft there.

Refs #1999
---
 .../paper/inbox/PaperTriageRowEdit.spec.ts    |  84 +++++++++++++++
 .../views/paper/inbox/PaperTriageRowEdit.vue  | 101 +++++++++++++++++-
 2 files changed, 184 insertions(+), 1 deletion(-)

diff --git a/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageRowEdit.spec.ts b/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageRowEdit.spec.ts
index 799dfab7c..4c86fdca9 100644
--- a/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageRowEdit.spec.ts
+++ b/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageRowEdit.spec.ts
@@ -418,4 +418,88 @@ describe('PaperTriageRowEdit', () => {
     expect(mockCaptureStore.updateSuggestion).not.toHaveBeenCalled()
     expect(wrapper.emitted('close')).toHaveLength(1)
   })
+
+  // ── the draft hand-off, so a row that leaves the list can keep it (#1999) ──
+
+  it('hands out the unsaved draft, and nothing while there is nothing unsaved', async () => {
+    mockCaptureStore.fetchDetail.mockResolvedValue(
+      makeDetail({ metadata: { dueDate: '2026-05-01', labels: ['ops'] } }),
+    )
+    const wrapper = await mountEditor()
+
+    // An opened-but-untouched editor holds no correction; saying otherwise
+    // would have the table announce a loss that did not happen.
+    expect(wrapper.vm.readDraft()).toBeNull()
+
+    await wrapper.get('[data-testid="capture-edit-textarea"]').setValue('Ship the release notes')
+    await wrapper.get('[data-testid="capture-edit-label-input"]').setValue('release')
+
+    expect(wrapper.vm.readDraft()).toEqual({
+      text: 'Ship the release notes',
+      dueDate: '2026-05-01',
+      labels: ['ops'],
+      // The uncommitted label box travels too: Save would have flushed it.
+      labelInput: 'release',
+    })
+  })
+
+  it('hands out nothing while the capture text has not loaded', async () => {
+    let resolveDetail: (detail: CaptureItem) => void = () => {}
+    mockCaptureStore.fetchDetail.mockImplementation(
+      () => new Promise<CaptureItem>((resolve) => { resolveDetail = resolve }),
+    )
+    const wrapper = mount(PaperTriageRowEdit, { props: { itemId: 'capture-1' } })
+    await flushPromises()
+
+    // There is no textarea yet, so an empty `draft` is the absence of data and
+    // not an edit — handing it out would let the table keep a blank correction.
+    expect(wrapper.vm.readDraft()).toBeNull()
+    resolveDetail(makeDetail())
+    await flushPromises()
+    expect(wrapper.vm.readDraft()).toBeNull()
+  })
+
+  it('restores a kept draft over the server text it re-reads, and says it did', async () => {
+    const wrapper = mount(PaperTriageRowEdit, {
+      props: {
+        itemId: 'capture-1',
+        restoredDraft: {
+          text: 'Ship the release notes before Friday',
+          dueDate: '',
+          labels: [],
+          labelInput: '',
+        },
+      },
+    })
+    await flushPromises()
+
+    // The fetch still happens: the ORIGINAL the draft is compared against has
+    // to be the capture's current text, not the one it had when it left.
+    expect(mockCaptureStore.fetchDetail).toHaveBeenCalledWith(
+      'capture-1',
+      expect.objectContaining({ forceRefresh: true }),
+    )
+    expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
+      .toBe('Ship the release notes before Friday')
+    expect(wrapper.emitted('restored')?.[0]).toEqual(['capture-1'])
+    // Restoring is a local rehydration, never a write.
+    expect(mockCaptureStore.updateSuggestion).not.toHaveBeenCalled()
+    // And Save is live, because the restored text differs from the server's.
+    expect(wrapper.get('button[data-action="edit-save"]').attributes('disabled')).toBeUndefined()
+  })
+
+  it('does not restore a draft into a capture the server refuses to edit', async () => {
+    mockCaptureStore.fetchDetail.mockResolvedValue(makeDetail({ canEditSuggestion: false }))
+    const wrapper = mount(PaperTriageRowEdit, {
+      props: {
+        itemId: 'capture-1',
+        restoredDraft: { text: 'a correction with nowhere to land', dueDate: '', labels: [], labelInput: '' },
+      },
+    })
+    await flushPromises()
+
+    expect(wrapper.find('[data-testid="capture-edit-blocked"]').exists()).toBe(true)
+    expect(wrapper.find('[data-testid="capture-edit-textarea"]').exists()).toBe(false)
+    expect(wrapper.emitted('restored')).toBeUndefined()
+  })
 })
diff --git a/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageRowEdit.vue b/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageRowEdit.vue
index f6629ca14..c9ef660b5 100644
--- a/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageRowEdit.vue
+++ b/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageRowEdit.vue
@@ -1,3 +1,26 @@
+<script lang="ts">
+/**
+ * One editor's unsaved correction, in the shape `PaperTriageTable` holds while
+ * the capture is off the list and hands back when it returns (#1999 item 3).
+ *
+ * It is deliberately the DRAFT side only — the server's own text, due date and
+ * labels are re-read on the way back in, so a kept correction is always
+ * measured against what the capture says now rather than what it said when the
+ * board filter changed. `labelInput` travels with the rest because Save
+ * flushes it into the payload: leaving it behind would silently drop a label
+ * the user had typed but not yet committed with Enter.
+ *
+ * Exported from a plain `<script>` block so the table can name the type it is
+ * holding; `<script setup>` cannot export.
+ */
+export type PaperTriageDraft = {
+  text: string
+  dueDate: string
+  labels: string[]
+  labelInput: string
+}
+</script>
+
 <script setup lang="ts">
 import { computed, onMounted, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
@@ -51,11 +74,18 @@ import type { CaptureItem } from '../../../types/capture'
 const props = defineProps<{
   itemId: string
   mutationInFlight?: boolean
+  /**
+   * A correction this table kept while the capture was off the list (#1999).
+   * Applied over the freshly loaded server values, once, and only on the
+   * editable path — see `applyRestoredDraft`.
+   */
+  restoredDraft?: PaperTriageDraft | null
 }>()
 
 const emit = defineEmits<{
   (event: 'close'): void
   (event: 'saved', itemId: string): void
+  (event: 'restored', itemId: string): void
 }>()
 
 const captureStore = useCaptureStore()
@@ -80,6 +110,7 @@ const originalDueDate = ref('')
 const labelInput = ref('')
 const labelsDraft = ref<string[]>([])
 const originalLabels = ref<string[]>([])
+const restoreApplied = ref(false)
 
 const textareaId = computed(() => `capture-edit-text-${props.itemId}`)
 const dueDateId = computed(() => `capture-edit-due-date-${props.itemId}`)
@@ -136,10 +167,20 @@ function removeLabel(index: number) {
  */
 type SaveBlock = 'busyElsewhere' | 'empty' | 'unchanged'
 
+/**
+ * Whether anything here differs from what the server last returned.
+ *
+ * One definition, read by `saveBlock` (as `unchanged`) and by `readDraft`, so
+ * "there is nothing to save" and "there is nothing worth keeping" can never
+ * disagree — the table would otherwise announce a kept correction over an
+ * editor the user never typed in.
+ */
+const isDirty = computed(() => draft.value !== originalText.value || metadataChanged.value)
+
 const saveBlock = computed<SaveBlock | null>(() => {
   if (props.mutationInFlight === true) return 'busyElsewhere'
   if (draft.value.trim().length === 0) return 'empty'
-  if (draft.value === originalText.value && !metadataChanged.value) return 'unchanged'
+  if (!isDirty.value) return 'unchanged'
   return null
 })
 
@@ -169,6 +210,63 @@ watch([draft, dueDateDraft, labelsDraft], () => {
   saveErrorMessage.value = null
 })
 
+/**
+ * Put a kept correction back over the values just read from the server
+ * (#1999 item 3).
+ *
+ * Called from inside `load`, on the editable path ONLY: the `blocked` and
+ * `error` branches return before it, so a capture the server now refuses to
+ * edit never gets a textarea seeded with text it would not accept, and the
+ * table keeps holding the correction instead.
+ *
+ * Once, guarded by `restoreApplied` rather than by the prop going null — the
+ * table holds the kept copy until the editor is closed explicitly, so a Retry
+ * after a failed load still restores, while a second successful load can never
+ * overwrite what the user has typed since the first one.
+ *
+ * Metadata is restored only when the server offered metadata this time.
+ * `metadataChanged` is gated on the same flag, so seeding a due date or labels
+ * the payload cannot carry would put values on screen that Save would drop.
+ */
+function applyRestoredDraft() {
+  const restored = props.restoredDraft
+  if (!restored || restoreApplied.value) return
+  restoreApplied.value = true
+  draft.value = restored.text
+  if (metadataAvailable.value) {
+    dueDateDraft.value = restored.dueDate
+    labelsDraft.value = [...restored.labels]
+    labelInput.value = restored.labelInput
+  }
+  emit('restored', props.itemId)
+}
+
+/**
+ * The unsaved correction, for the table to hold while this row is off the list
+ * (#1999 item 3) — or `null` when there is nothing to hold.
+ *
+ * A getter rather than an emit on unmount, because the table already knows the
+ * single moment the close is INVOLUNTARY (its `items` watcher, and the
+ * read-only switch) and reads the draft there. `close` fires on Cancel and on
+ * a completed Save too, so an unmount emit would make the table infer, from a
+ * flag set one line earlier, which kind of close it was — and get Cancel wrong
+ * the first time that inference broke.
+ *
+ * Only offered from the `ready` state: before the text lands there is no
+ * textarea, and an empty `draft` there is the absence of data, not an edit.
+ */
+function readDraft(): PaperTriageDraft | null {
+  if (loadState.value !== 'ready' || !isDirty.value) return null
+  return {
+    text: draft.value,
+    dueDate: dueDateDraft.value,
+    labels: [...labelsDraft.value],
+    labelInput: labelInput.value,
+  }
+}
+
+defineExpose({ readDraft })
+
 async function load() {
   loadState.value = 'loading'
   loadErrorMessage.value = null
@@ -204,6 +302,7 @@ async function load() {
     originalLabels.value = [...(detail.metadata?.labels ?? [])]
     labelsDraft.value = [...originalLabels.value]
     labelInput.value = ''
+    applyRestoredDraft()
     loadState.value = 'ready'
   } catch (e: unknown) {
     loadErrorMessage.value = getErrorDisplay(e, t('inbox.triage.edit.unknownReason')).message

From 98ea17fb2fbc13584ad37003c43e4c8e120e06c4 Mon Sep 17 00:00:00 2001
From: Chris0Jeky <jeky.tck@gmail.com>
Date: Sat, 5 Sep 2026 17:25:14 +0100
Subject: [PATCH 2/3] fix(inbox): keep and announce an unsaved triage
 correction when its row leaves the list

Switching the Inbox board filter while a Paper row editor was open let the
draft survive the replacement and then, once the new list landed without the
edited row, the items watcher cleared editItemId and the correction went with
the unmounted editor. Nothing said so. That was the silent loss the sibling
edit gate and the decision block already refuse one row over.

The table now reads the editor's unsaved draft at the one moment the close is
involuntary and holds it, keyed by capture id, in component state. A
role="status" receipt above the list names the capture by the excerpt the row
showed and says the correction is kept and comes back with it. When the
capture returns the editor reopens with the draft laid over freshly re-read
server text, unless another editor is open, in which case the correction stays
held and the receipt says so. It is dropped only when the capture comes back
in a state this surface cannot edit, again with a receipt that names the
status. Cancel and Save are unchanged and both release the held copy.

The read-only history switch closes the editor through its own watcher, so it
takes the correction the same way rather than leaving a second silent door.

Nothing is persisted and nothing reaches the server: a restored editor's Save
is the same explicit write it always was. Copy in inbox.triage.draft for en,
es and it.

Refs #1999
---
 frontend/taskdeck-web/src/locales/en/inbox.ts |  20 ++
 frontend/taskdeck-web/src/locales/es/inbox.ts |  14 +
 frontend/taskdeck-web/src/locales/it/inbox.ts |  15 +
 .../paper/inbox/PaperTriageTable.spec.ts      | 203 ++++++++++++-
 .../views/paper/inbox/PaperTriageTable.vue    | 269 +++++++++++++++++-
 5 files changed, 511 insertions(+), 10 deletions(-)

diff --git a/frontend/taskdeck-web/src/locales/en/inbox.ts b/frontend/taskdeck-web/src/locales/en/inbox.ts
index d80d0940e..d5e6d7858 100644
--- a/frontend/taskdeck-web/src/locales/en/inbox.ts
+++ b/frontend/taskdeck-web/src/locales/en/inbox.ts
@@ -246,6 +246,26 @@ export default {
       state: 'State: {label}. Where this capture stands right now.',
       source: 'Source: {label}. How this capture arrived — not a state.',
     },
+    // The fate of an unsaved correction whose capture left the list (#1999
+    // item 3) — a board-filter change, a refresh that no longer returns the
+    // row, or the switch into archived history.
+    //
+    // These are RECEIPTS, not warnings: by the time one renders the decision
+    // has already been taken, so each says what happened to the correction and
+    // where it now is. `{capture}` is the row's own excerpt, so the sentence
+    // names the same thing the list did.
+    //
+    // `discarded` is the only sentence about a loss, and it is the only case
+    // where one is possible: the capture came back in a state this surface
+    // cannot edit, so there is nowhere for the correction to go. It states the
+    // status that closed the door rather than leaving the drop unexplained.
+    draft: {
+      kept: 'The unsaved correction to “{capture}” was not lost. It is held here and comes back with that capture when it returns to this list. Nothing was saved.',
+      restored: 'The unsaved correction to “{capture}” is back in the editor, over the capture text as it stands now. Save it or cancel as usual.',
+      blocked: 'The unsaved correction to “{capture}” is still held. Another capture is open for editing — finish that one, then choose Edit capture on this row to get the correction back.',
+      discarded: 'The unsaved correction to “{capture}” was dropped: the capture is now {status}, and its text can no longer be edited here. Nothing was saved.',
+      dismiss: 'Dismiss these notes',
+    },
     // Pre-triage text correction (GH-1951) — the Legacy detail panel's
     // "Edit Text" affordance, ported to the Paper row.
     //
diff --git a/frontend/taskdeck-web/src/locales/es/inbox.ts b/frontend/taskdeck-web/src/locales/es/inbox.ts
index 1b8e45216..e4a631598 100644
--- a/frontend/taskdeck-web/src/locales/es/inbox.ts
+++ b/frontend/taskdeck-web/src/locales/es/inbox.ts
@@ -174,6 +174,20 @@ export default {
       state: 'Estado: {label}. Dónde está ahora mismo esta captura.',
       source: 'Origen: {label}. Cómo llegó esta captura — no es un estado.',
     },
+    // Destino de una corrección sin guardar cuya captura sale de la lista
+    // (#1999, punto 3): un cambio del filtro de tablero, una recarga que ya no
+    // devuelve la fila, o el paso al historial de solo lectura.
+    //
+    // Son RECIBOS, no avisos: cuando se muestran la decisión ya está tomada,
+    // así que cada uno dice qué pasó con la corrección y dónde está ahora.
+    // `{capture}` es el extracto de la propia fila.
+    draft: {
+      kept: 'La corrección sin guardar de “{capture}” no se ha perdido. Se conserva aquí y vuelve con esa captura cuando reaparezca en esta lista. No se guardó nada.',
+      restored: 'La corrección sin guardar de “{capture}” vuelve a estar en el editor, sobre el texto que la captura tiene ahora. Guárdala o cancela como siempre.',
+      blocked: 'La corrección sin guardar de “{capture}” sigue conservada. Otra captura está abierta para editar: termina esa y luego pulsa Editar captura en esta fila para recuperarla.',
+      discarded: 'La corrección sin guardar de “{capture}” se descartó: la captura ahora está {status} y su texto ya no se puede editar aquí. No se guardó nada.',
+      dismiss: 'Descartar estos avisos',
+    },
     // Corrección del texto antes de clasificar (GH-1951).
     //
     // `blocked.notEditable` enuncia el HECHO, no la causa: el servidor rechaza
diff --git a/frontend/taskdeck-web/src/locales/it/inbox.ts b/frontend/taskdeck-web/src/locales/it/inbox.ts
index b93ee9e9a..f85a9f515 100644
--- a/frontend/taskdeck-web/src/locales/it/inbox.ts
+++ b/frontend/taskdeck-web/src/locales/it/inbox.ts
@@ -171,6 +171,21 @@ export default {
       state: 'Stato: {label}. Il punto in cui si trova ora questa cattura.',
       source: 'Origine: {label}. Come è arrivata questa cattura — non è uno stato.',
     },
+    // Destino di una correzione non salvata la cui cattura esce dall'elenco
+    // (#1999, punto 3): un cambio del filtro bacheca, un aggiornamento che non
+    // restituisce più la riga, oppure il passaggio allo storico in sola
+    // lettura.
+    //
+    // Sono RICEVUTE, non avvisi: quando compaiono la decisione è già presa, e
+    // ognuna dice che fine ha fatto la correzione e dov'è adesso.
+    // `{capture}` è l'estratto della riga stessa.
+    draft: {
+      kept: 'La correzione non salvata di “{capture}” non è andata persa. Resta conservata qui e torna con quella cattura quando ricompare in questo elenco. Non è stato salvato nulla.',
+      restored: 'La correzione non salvata di “{capture}” è di nuovo nell\'editor, sopra il testo che la cattura ha ora. Salvala o annulla come sempre.',
+      blocked: 'La correzione non salvata di “{capture}” resta conservata. Un\'altra cattura è aperta in modifica: concludi quella, poi premi Modifica cattura su questa riga per riprenderla.',
+      discarded: 'La correzione non salvata di “{capture}” è stata scartata: la cattura ora è {status} e il suo testo non è più modificabile qui. Non è stato salvato nulla.',
+      dismiss: 'Chiudi queste note',
+    },
     // Correzione del testo prima dello smistamento (GH-1951).
     //
     // `blocked.notEditable` dichiara il FATTO, non la causa: il server rifiuta
diff --git a/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageTable.spec.ts b/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageTable.spec.ts
index 238bfa11f..812d82acc 100644
--- a/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageTable.spec.ts
+++ b/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageTable.spec.ts
@@ -1104,15 +1104,214 @@ describe('PaperTriageTable', () => {
     expect(wrapper.get('button[data-action="edit-save"]').attributes('disabled')).toBeDefined()
   })
 
-  it('closes a stale editor when its row leaves the list', async () => {
+  // --- draft fate when the edited row leaves the list (#1999 item 3) --------
+
+  /**
+   * Until now this closed the editor and destroyed the unsaved correction
+   * WITHOUT a word: switching the Inbox board filter replaced the list, the
+   * edited row was not in the replacement, and the `items` watcher cleared
+   * `editItemId`. The draft went with the unmounted child. That was pinned as
+   * intended; the pin is replaced here by preserve-and-announce.
+   *
+   * The list replacement below IS the board-filter change as this component
+   * sees it: `useInboxOrchestrator`'s `activeBoardId` watcher reloads the
+   * inbox for the new scope and a new `items` array arrives. A same-scope
+   * refresh that drops the row reaches the table through exactly the same
+   * prop, which is why one case covers both.
+   */
+  async function openEditorAndType(
+    wrapper: ReturnType<typeof mount>,
+    rowIndex: number,
+    text: string,
+  ) {
+    await wrapper.findAll('button[data-action="edit"]')[rowIndex].trigger('click')
+    await flushPromises()
+    await wrapper.get('[data-testid="capture-edit-textarea"]').setValue(text)
+    return text
+  }
+
+  it('keeps an unsaved correction and names the capture when its row leaves the list', async () => {
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    const typed = await openEditorAndType(wrapper, 0, 'a correction the filter change must not eat')
+
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+
+    // The editor still closes — the row it belongs to is gone.
+    expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(false)
+
+    const notices = wrapper.get('[data-testid="capture-draft-notices"]')
+    expect(notices.attributes('role')).toBe('status')
+    const kept = notices.get('[data-notice="kept"]')
+    // Named by the same excerpt the row shows, so the user knows WHICH capture.
+    expect(kept.text()).toContain('First excerpt')
+    expect(kept.text()).toContain('comes back')
+
+    // Nothing was written anywhere: this is component state, not a save.
+    expect(mockCaptureStore.updateSuggestion).not.toHaveBeenCalled()
+    expect(wrapper.emitted('accept')).toBeUndefined()
+    expect(wrapper.emitted('keep')).toBeUndefined()
+    expect(wrapper.emitted('reject')).toBeUndefined()
+    expect(typed.length).toBeGreaterThan(0)
+  })
+
+  it('says nothing and keeps nothing when the row leaves with an untouched editor', async () => {
+    // The receipt must describe a real loss. An editor that was opened and not
+    // typed into has no correction to keep, and announcing one would be noise.
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+
+    expect(wrapper.find('[data-testid="capture-draft-notices"]').exists()).toBe(false)
+  })
+
+  it('restores the kept correction when the capture returns to the list', async () => {
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    const typed = await openEditorAndType(wrapper, 0, 'the correction that has to survive the round trip')
+
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+    await wrapper.setProps({ items: makeItems() })
+    await flushPromises()
+
+    const rows = wrapper.findAll('.paper-triage__row')
+    expect(rows[0].find('[data-testid="capture-edit"]').exists()).toBe(true)
+    expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
+      .toBe(typed)
+    expect(wrapper.get('[data-testid="capture-draft-notices"]').get('[data-notice="restored"]').text())
+      .toContain('First excerpt')
+    // The server's current text is re-read on the way back in, so the draft is
+    // measured against what the capture says NOW, not what it said before.
+    expect(mockCaptureStore.fetchDetail).toHaveBeenCalledTimes(2)
+    expect(mockCaptureStore.updateSuggestion).not.toHaveBeenCalled()
+  })
+
+  it('refuses a second editor when the capture returns, and keeps the correction', async () => {
+    const items = makeItems()
+    items[1] = { ...items[1], status: 'New' }
+    const wrapper = mount(PaperTriageTable, { props: { items } })
+    const typed = await openEditorAndType(wrapper, 0, 'a correction waiting for its row')
+
+    // capture-1 leaves; its correction is kept.
+    await wrapper.setProps({ items: items.slice(1) })
+    await flushPromises()
+
+    // The user starts editing the row that stayed, then capture-1 comes back.
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+    await wrapper.setProps({ items })
+    await flushPromises()
+
+    // One editor, on capture-2 — the open-editor gate is not broken by a return.
+    const rows = wrapper.findAll('.paper-triage__row')
+    expect(wrapper.findAll('[data-testid="capture-edit"]')).toHaveLength(1)
+    expect(rows[1].find('[data-testid="capture-edit"]').exists()).toBe(true)
+    expect(rows[0].find('[data-testid="capture-edit"]').exists()).toBe(false)
+    expect(wrapper.get('[data-testid="capture-draft-notices"]').get('[data-notice="blocked"]').text())
+      .toContain('First excerpt')
+
+    // Still kept: closing the open editor and asking for capture-1 brings it back.
+    await wrapper.get('button[data-action="edit-cancel"]').trigger('click')
+    await flushPromises()
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+    expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
+      .toBe(typed)
+  })
+
+  it('drops a kept correction with a stated reason once the capture is no longer editable', async () => {
     const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    await openEditorAndType(wrapper, 0, 'a correction for a capture that moved on')
+
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+
+    // capture-1 comes back Triaged: the surface can no longer edit it, so the
+    // correction has nowhere to go and is dropped — with a receipt.
+    const triaged = makeItems()
+    triaged[0] = { ...triaged[0], status: 'Triaged' }
+    await wrapper.setProps({ items: triaged })
+    await flushPromises()
+
+    const discarded = wrapper.get('[data-testid="capture-draft-notices"]').get('[data-notice="discarded"]')
+    expect(discarded.text()).toContain('First excerpt')
+    expect(discarded.text()).toContain('Triaged')
+    expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(false)
+
+    // And it is really gone: an editable capture-1 later opens on server text.
+    await wrapper.setProps({ items: makeItems() })
+    await flushPromises()
+    expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(false)
     await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
     await flushPromises()
-    expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(true)
+    expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
+      .toBe('First excerpt in full')
+    expect(mockCaptureStore.updateSuggestion).not.toHaveBeenCalled()
+  })
+
+  it('does not drop a kept correction merely because the list changed again', async () => {
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    const typed = await openEditorAndType(wrapper, 0, 'a correction that outlives two filter changes')
+
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+    await wrapper.setProps({ items: [] })
+    await flushPromises()
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+    await wrapper.setProps({ items: makeItems() })
+    await flushPromises()
+
+    expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
+      .toBe(typed)
+  })
+
+  it('keeps the correction when the list switches to archived history', async () => {
+    // Entering read-only history clears the editor through its own watcher, so
+    // it is a second door onto the same silent loss.
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    await openEditorAndType(wrapper, 0, 'a correction interrupted by the archive')
+
+    await wrapper.setProps({ readOnly: true })
+    await flushPromises()
+
+    expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(false)
+    expect(wrapper.get('[data-testid="capture-draft-notices"]').get('[data-notice="kept"]').text())
+      .toContain('First excerpt')
+  })
+
+  it('lets the reader dismiss the draft receipt', async () => {
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    await openEditorAndType(wrapper, 0, 'a correction whose receipt has been read')
 
     await wrapper.setProps({ items: makeItems().slice(1) })
     await flushPromises()
 
+    await wrapper.get('button[data-action="dismiss-draft-notice"]').trigger('click')
+    expect(wrapper.find('[data-testid="capture-draft-notices"]').exists()).toBe(false)
+  })
+
+  it('forgets the correction when the user cancels the restored edit', async () => {
+    // Cancel still means cancel: the kept copy is not a second life for text
+    // the user has explicitly abandoned.
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    await openEditorAndType(wrapper, 0, 'a correction the user changed their mind about')
+
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+    await wrapper.setProps({ items: makeItems() })
+    await flushPromises()
+
+    await wrapper.get('button[data-action="edit-cancel"]').trigger('click')
+    await flushPromises()
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+    await wrapper.setProps({ items: makeItems() })
+    await flushPromises()
+
     expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(false)
   })
 })
diff --git a/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageTable.vue b/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageTable.vue
index 4f9b00990..b0434048c 100644
--- a/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageTable.vue
+++ b/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageTable.vue
@@ -1,9 +1,9 @@
 <script setup lang="ts">
-import { computed, nextTick, onMounted, ref, watch } from 'vue'
+import { computed, nextTick, onMounted, ref, shallowRef, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import PaperHLBtn from '../../../components/paper/PaperHLBtn.vue'
 import PaperTagstamp from '../../../components/paper/PaperTagstamp.vue'
-import PaperTriageRowEdit from './PaperTriageRowEdit.vue'
+import PaperTriageRowEdit, { type PaperTriageDraft } from './PaperTriageRowEdit.vue'
 import { useBoardStore } from '../../../store/boardStore'
 import {
   canMutateSelection,
@@ -106,6 +106,103 @@ const boardListLoadState = ref<BoardListLoadState>(
 // two drafts and one Save.
 const editItemId = ref<string | null>(null)
 
+/**
+ * How the open editor's row is named once it is gone.
+ *
+ * Recorded when the editor opens, because the receipt below is written at the
+ * moment the row LEAVES the list — by then the summary that carries the
+ * excerpt is no longer in `items`, and a receipt that cannot say which capture
+ * it is about is barely a receipt.
+ */
+const editItemLabel = ref<string | null>(null)
+
+/**
+ * The open editor, so the table can read its unsaved draft at the one moment
+ * the close is involuntary (#1999 item 3).
+ *
+ * `shallowRef` and an array: the ref sits inside `v-for`, so Vue maintains it
+ * as a list. Only one editor is ever mounted (`isEditing`), so the list holds
+ * at most one entry.
+ */
+const openEditorRefs = shallowRef<InstanceType<typeof PaperTriageRowEdit>[]>([])
+
+/**
+ * Unsaved corrections whose captures are currently off the list (#1999 item 3).
+ *
+ * Switching the Inbox board filter replaces `items`; a row being edited is
+ * usually not in the replacement, and the watcher below then closes its
+ * editor. That used to destroy the draft without a word — the same silent loss
+ * the sibling-edit gate and the decision block already refuse one row over.
+ *
+ * So the draft is held here instead, keyed by capture id, and put back when
+ * the capture returns. This is COMPONENT state and nothing else: nothing is
+ * persisted, and nothing reaches the server until the user presses Save in a
+ * restored editor exactly as they would have before. It lives as long as the
+ * table does, which is the span of the promise the receipt makes.
+ */
+type KeptDraft = { itemId: string; label: string; draft: PaperTriageDraft }
+const keptDrafts = ref(new Map<string, KeptDraft>())
+
+/**
+ * What just happened to a kept correction, in the surface's own receipt idiom.
+ *
+ * A list rather than one slot because a single list replacement can settle more
+ * than one correction's fate — a capture returning uneditable while another
+ * row's editor is being closed. Dropping either notice would make the surface
+ * silent about exactly the case it exists to narrate. The next run that has
+ * something to say replaces the whole list; a run with nothing to say leaves
+ * the standing notes alone, and the reader can dismiss them.
+ */
+type DraftNoticeKind = 'kept' | 'restored' | 'blocked' | 'discarded'
+type DraftNotice = { key: string; kind: DraftNoticeKind; capture: string; status: string }
+const draftNotices = ref<DraftNotice[]>([])
+let draftNoticeSeq = 0
+
+function draftNotice(kind: DraftNoticeKind, capture: string, status = ''): DraftNotice {
+  draftNoticeSeq += 1
+  return { key: `${kind}:${draftNoticeSeq}`, kind, capture, status }
+}
+
+function dismissDraftNotices() {
+  draftNotices.value = []
+}
+
+/**
+ * The capture as this list names it. The excerpt is what the row shows, so the
+ * receipt and the row agree; the id is the fallback the open button already
+ * uses when there is nothing else to say.
+ */
+function captureLabel(item: CaptureItemSummary): string {
+  const excerpt = typeof item.textExcerpt === 'string' ? item.textExcerpt.trim() : ''
+  return excerpt || item.id
+}
+
+function restoredDraftFor(item: CaptureItemSummary): PaperTriageDraft | null {
+  return keptDrafts.value.get(item.id)?.draft ?? null
+}
+
+/**
+ * Take the open editor's unsaved correction into the kept map before the editor
+ * goes away, and answer with the receipt that says so — or `null` when there
+ * was nothing unsaved to take.
+ *
+ * The stale-entry delete matters: a restored correction the user has since
+ * typed back to the server's own text is no longer a correction, and leaving
+ * the old copy in the map would resurrect it on the next return.
+ */
+function keepOpenDraft(): DraftNotice | null {
+  const itemId = editItemId.value
+  if (itemId === null) return null
+  const label = editItemLabel.value ?? itemId
+  const draft = openEditorRefs.value[0]?.readDraft() ?? null
+  if (draft === null) {
+    keptDrafts.value.delete(itemId)
+    return null
+  }
+  keptDrafts.value.set(itemId, { itemId, label, draft })
+  return draftNotice('kept', label)
+}
+
 /**
  * Which action this table started, for which row (#1944).
  *
@@ -136,14 +233,70 @@ watch(
   },
 )
 
+/**
+ * What a list replacement does to an unsaved correction (#1999 item 3).
+ *
+ * The board filter is not visible from here: switching it makes the
+ * orchestrator load the new scope and hand this table a different `items`
+ * array, which is also what a refresh that no longer returns the row does. One
+ * watcher therefore answers both, and the three outcomes it can reach are all
+ * spoken aloud.
+ *
+ * Ordering is deliberate. The discard sweep runs first, so a correction whose
+ * capture came back uneditable is settled before anything else; the departure
+ * is handled next, because it is the event that produces new held state; and
+ * the return is considered last and only when nothing departed in the same
+ * run, so a single replacement never both takes a correction away and reopens
+ * an editor somewhere else.
+ */
 watch(
   () => props.items,
-  (rows) => {
-    // A row that has left the list can no longer be edited, and leaving the id
-    // set would silently reopen the editor if a row with that id came back.
-    if (editItemId.value !== null && !rows.some((row) => row.id === editItemId.value)) {
+  (rows, previousRows) => {
+    const notices: DraftNotice[] = []
+
+    // A held correction has nowhere to land once its capture leaves the states
+    // this surface can edit. This is the ONLY case where one is dropped, and
+    // the receipt names the status that closed the door. Time passing, or the
+    // filter changing again, never drops one.
+    for (const row of rows) {
+      const kept = keptDrafts.value.get(row.id)
+      if (!kept || canMutate(row)) continue
+      keptDrafts.value.delete(row.id)
+      notices.push(draftNotice('discarded', kept.label, statusLabel(row.status)))
+    }
+
+    // The edited row is not in the replacement. The editor still closes — the
+    // row it belongs to is gone — but its draft is taken first.
+    const departed = editItemId.value !== null && !rows.some((row) => row.id === editItemId.value)
+    if (departed) {
+      const kept = keepOpenDraft()
       editItemId.value = null
+      editItemLabel.value = null
+      if (kept) notices.push(kept)
+    }
+
+    // A held correction's capture is back. Only a capture that was absent from
+    // the previous list counts as returning: a row that has simply been on
+    // screen all along must not reopen an editor on every refresh.
+    if (!departed) {
+      const previous = new Set((previousRows ?? []).map((row) => row.id))
+      const returning = rows.find((row) => keptDrafts.value.has(row.id) && !previous.has(row.id))
+      if (returning) {
+        const label = keptDrafts.value.get(returning.id)?.label ?? returning.id
+        if (editItemId.value !== null) {
+          // The one-editor-at-a-time gate outranks the restore: opening a
+          // second editor here would be the exact two-drafts-one-Save state
+          // `isEditingElsewhere` exists to prevent. The correction stays held.
+          notices.push(draftNotice('blocked', label))
+        } else if (!isActionDisabled(returning)) {
+          // The editor announces the restore itself, once the draft is
+          // actually back over the re-read server text.
+          openEditor(returning)
+        }
+      }
     }
+
+    if (notices.length > 0) draftNotices.value = notices
   },
 )
 
@@ -151,7 +304,13 @@ watch(
   () => props.readOnly,
   (readOnly) => {
     if (!readOnly) return
+    // Entering archived history closes the editor through this watcher rather
+    // than through the list, so it is a second door onto the same loss: take
+    // the correction the same way, and say so.
+    const kept = keepOpenDraft()
+    if (kept) draftNotices.value = [kept]
     editItemId.value = null
+    editItemLabel.value = null
     boardPickItemId.value = null
     pickedBoardId.value = null
   },
@@ -288,17 +447,44 @@ function isActionDisabled(item: CaptureItemSummary): boolean {
     isEditingElsewhere(item)
 }
 
-function onEdit(item: CaptureItemSummary) {
-  if (isActionDisabled(item)) return
+/**
+ * The single way the editor opens, whether the user asked or a held correction
+ * came back with its row — so both routes record the row's name for the
+ * receipt and both cancel a board pick in progress.
+ */
+function openEditor(item: CaptureItemSummary) {
   // Opening the editor cancels a board pick in progress: they compete for the
   // same row and the same decision, and leaving both open would let a stale
   // pick confirm against text that is being rewritten.
   cancelBoardPick()
   editItemId.value = item.id
+  editItemLabel.value = captureLabel(item)
 }
 
+function onEdit(item: CaptureItemSummary) {
+  if (isActionDisabled(item)) return
+  openEditor(item)
+}
+
+/**
+ * An EXPLICIT end to the edit — Cancel, or a Save that landed (the editor
+ * emits `close` for both).
+ *
+ * Either way the correction stops being unsaved text the user is owed: a saved
+ * one is on the server, and a cancelled one was abandoned on purpose. Holding
+ * a copy past that point would hand it back on the next return, which is the
+ * opposite of what Cancel means.
+ */
 function closeEdit() {
+  if (editItemId.value !== null) keptDrafts.value.delete(editItemId.value)
   editItemId.value = null
+  editItemLabel.value = null
+}
+
+/** The editor has put a held correction back; say which one, once it is true. */
+function onDraftRestored(itemId: string) {
+  const label = keptDrafts.value.get(itemId)?.label ?? editItemLabel.value ?? itemId
+  draftNotices.value = [draftNotice('restored', label)]
 }
 
 function hasBoard(item: CaptureItemSummary): boolean {
@@ -567,6 +753,38 @@ function recordedOr(value: string | null | undefined): string {
       </span>
     </header>
 
+    <!--
+      What became of an unsaved correction whose capture left the list (#1999
+      item 3). It sits above the list rather than on a row because the capture
+      it is about is usually not on screen when it is written, and it outlives
+      the row that produced it. `role="status"` and not `alert`: nothing has
+      gone wrong in the kept, restored and blocked cases, and even the discard
+      is a stated consequence rather than a failure.
+    -->
+    <div
+      v-if="draftNotices.length > 0"
+      class="paper-triage__draft-notices"
+      role="status"
+      data-testid="capture-draft-notices"
+    >
+      <p
+        v-for="notice in draftNotices"
+        :key="notice.key"
+        class="paper-triage__draft-notice"
+        :data-notice="notice.kind"
+      >
+        {{ t(`inbox.triage.draft.${notice.kind}`, { capture: notice.capture, status: notice.status }) }}
+      </p>
+      <button
+        type="button"
+        class="paper-triage__retry paper-triage__draft-dismiss"
+        data-action="dismiss-draft-notice"
+        @click="dismissDraftNotices"
+      >
+        {{ t('inbox.triage.draft.dismiss') }}
+      </button>
+    </div>
+
     <div v-if="listError" class="paper-triage__empty paper-triage__empty--error" role="alert">
       <p class="tk-body">{{ listError }}</p>
       <button type="button" class="paper-triage__retry" @click="emit('retry')">
@@ -875,10 +1093,20 @@ function recordedOr(value: string | null | undefined): string {
             mid-flight, and the early release re-opens a second enqueue. The
             editor cannot see the slot, so the table hands it over.
           -->
+          <!--
+            `restored-draft` is the correction this table held while the
+            capture was off the list (#1999). The editor re-reads the server
+            text either way and lays the draft over it, so a restore is never
+            a stale write: what Save sends is measured against the capture as
+            it stands now.
+          -->
           <PaperTriageRowEdit
+            ref="openEditorRefs"
             :item-id="item.id"
             :mutation-in-flight="hasMutationInFlight"
+            :restored-draft="restoredDraftFor(item)"
             @close="closeEdit"
+            @restored="onDraftRestored"
           />
         </div>
 
@@ -941,6 +1169,31 @@ function recordedOr(value: string | null | undefined): string {
   text-transform: uppercase;
   cursor: pointer;
 }
+/*
+ * The draft-fate receipt (#1999 item 3). Set in the note palette rather than
+ * the failure one: three of its four sentences are about a correction that was
+ * KEPT, and the fourth is a stated consequence, not an error.
+ */
+.paper-triage__draft-notices {
+  margin-bottom: 12px;
+  padding: 10px 12px;
+  border: 1px solid var(--line-soft);
+  border-left: 2px solid var(--ember);
+  border-radius: 3px;
+  background: var(--paper-card);
+}
+.paper-triage__draft-notice {
+  margin: 0 0 4px;
+  max-width: 72ch;
+  font-family: var(--sans);
+  font-size: 12px;
+  line-height: 1.4;
+  color: var(--ink-2);
+  overflow-wrap: anywhere;
+}
+.paper-triage__draft-dismiss {
+  margin-top: 6px;
+}
 .paper-triage__list {
   margin: 0;
   padding: 0;

From 94859670a84087bb16e9697fbb1f40a24ca7edf1 Mon Sep 17 00:00:00 2001
From: Chris0Jeky <jeky.tck@gmail.com>
Date: Sat, 5 Sep 2026 17:53:07 +0100
Subject: [PATCH 3/3] fix(inbox): make the held-correction mechanism answer
 honestly in every path
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Review round 2 on PR #2698. Every item below is one change to the same
mechanism, so they land together: the editor's answer, the table's use of it,
and what the surface says are not separable into commits that build.

HIGH — readDraft conflated "nothing unsaved" with "I cannot tell". It returned
null both when the draft matched the server text and when the editor was still
loading, had failed to load, or had been refused. Two paths then destroyed a
held correction silently: keepOpenDraft released it when a restore's detail
read was still pending or had failed and the list changed again, and closeEdit
released it on a close emitted by the load-error panel's Cancel or the refused
panel's Close, where the reader had never seen the correction at all. The
editor now answers { state: 'ready', draft } or { state: 'unavailable' }; the
table releases a held copy only on a ready report with an empty draft, or on a
close from a ready editor. An unavailable report changes nothing held.

Design — the automatic restore is gone. A held correction comes back only
through the reader's own Edit capture, the explicit action this surface
requires everywhere else. That removes an editor opening by itself with text
nobody asked for, a list arriving and cancelling a board pick in progress on
another row, and a silent non-restore when the returning row happened to be
action-disabled. What replaces it is a standing line per capture, derived from
items, keptDrafts and the open editor rather than from a previous-versus-
current diff, so it is always true, states itself for every capture that
qualifies, and cannot miss a second one.

MEDIUM — notices are one line per capture and merge instead of replacing, so a
restored line cannot wipe another capture's discarded receipt. Standing lines
disappear when they stop being true; receipts stand until that capture's next
receipt, until the edit they describe ends from a loaded editor, or until
dismissed.

MEDIUM — the discard sweep skips a capture whose editor is open, and keys on
the server's own rule rather than this list's action gate: only
ProposalCreated, Converted and Ignored drop a correction, because those are the
settled states CaptureService would refuse the edit in. Triaged keeps it (the
Paper gate is a product policy the D-13 ruling can move), Triaging keeps it (a
transient), and an unrecognised status keeps it.

MEDIUM — the live region is mounted and silent from the start, so a notice is a
mutation of a region that was already there rather than an insertion.

MEDIUM — per-field dirty tracking. The held draft carries only the fields the
reader changed, and the editor lays only those over the values it re-reads, so
a text correction can no longer revert a due date or a label that moved on the
server while it was held. The template comment claiming a restore is never a
stale write is replaced by the truth: Save is last-write-wins, as it is from an
editor opened fresh.

LOW — dismiss returns focus to the region that survives it; the kept sentence
says the correction is held while the reader stays on this Inbox list, which is
what the Map's lifetime actually promises.

Refs #1999
---
 frontend/taskdeck-web/src/locales/en/inbox.ts |  33 +-
 frontend/taskdeck-web/src/locales/es/inbox.ts |  23 +-
 frontend/taskdeck-web/src/locales/it/inbox.ts |  24 +-
 .../paper/inbox/PaperTriageRowEdit.spec.ts    |  89 +++--
 .../paper/inbox/PaperTriageTable.spec.ts      | 325 ++++++++++++++---
 .../views/paper/inbox/PaperTriageRowEdit.vue  | 112 ++++--
 .../views/paper/inbox/PaperTriageTable.vue    | 344 ++++++++++++------
 7 files changed, 702 insertions(+), 248 deletions(-)

diff --git a/frontend/taskdeck-web/src/locales/en/inbox.ts b/frontend/taskdeck-web/src/locales/en/inbox.ts
index d5e6d7858..10601a69f 100644
--- a/frontend/taskdeck-web/src/locales/en/inbox.ts
+++ b/frontend/taskdeck-web/src/locales/en/inbox.ts
@@ -246,24 +246,29 @@ export default {
       state: 'State: {label}. Where this capture stands right now.',
       source: 'Source: {label}. How this capture arrived — not a state.',
     },
-    // The fate of an unsaved correction whose capture left the list (#1999
+    // Where an unsaved correction stands once its capture left the list (#1999
     // item 3) — a board-filter change, a refresh that no longer returns the
-    // row, or the switch into archived history.
+    // row, or the switch into archived history. `{capture}` is the row's own
+    // excerpt, so the sentence names the same thing the list did.
     //
-    // These are RECEIPTS, not warnings: by the time one renders the decision
-    // has already been taken, so each says what happened to the correction and
-    // where it now is. `{capture}` is the row's own excerpt, so the sentence
-    // names the same thing the list did.
+    // `kept` and `discarded` are receipts about a moment. `held`, `blocked` and
+    // `heldUneditable` are standing statements, true for as long as they are on
+    // screen, so each ends by saying what the reader can do about it.
     //
-    // `discarded` is the only sentence about a loss, and it is the only case
-    // where one is possible: the capture came back in a state this surface
-    // cannot edit, so there is nowhere for the correction to go. It states the
-    // status that closed the door rather than leaving the drop unexplained.
+    // `kept` says "this Inbox list" on purpose. The correction lives in the
+    // table for as long as the table does; promising it back after a reload
+    // would be a promise this mechanism cannot keep.
+    //
+    // `discarded` is the only sentence about a loss, and it is reached only
+    // from a status the SERVER itself would refuse the edit in. It states that
+    // status rather than leaving the drop unexplained.
     draft: {
-      kept: 'The unsaved correction to “{capture}” was not lost. It is held here and comes back with that capture when it returns to this list. Nothing was saved.',
-      restored: 'The unsaved correction to “{capture}” is back in the editor, over the capture text as it stands now. Save it or cancel as usual.',
-      blocked: 'The unsaved correction to “{capture}” is still held. Another capture is open for editing — finish that one, then choose Edit capture on this row to get the correction back.',
-      discarded: 'The unsaved correction to “{capture}” was dropped: the capture is now {status}, and its text can no longer be edited here. Nothing was saved.',
+      kept: 'The unsaved correction to “{capture}” was not lost. It is held while you stay on this Inbox list, and comes back with that capture when it returns. Nothing was saved.',
+      held: 'The unsaved correction to “{capture}” is still held. Choose Edit capture on that row to bring it back.',
+      blocked: 'The unsaved correction to “{capture}” is still held. Another capture is open for editing — finish that one, then choose Edit capture on this row to bring the correction back.',
+      heldUneditable: 'The unsaved correction to “{capture}” is still held. This list does not edit a capture that is {status}, so the correction waits here until that capture can be edited again.',
+      restored: 'The unsaved correction to “{capture}” is back in the editor, over the capture as it stands now. Save it or cancel as usual.',
+      discarded: 'The unsaved correction to “{capture}” was dropped: the capture is now {status}, and its text can no longer be edited. Nothing was saved.',
       dismiss: 'Dismiss these notes',
     },
     // Pre-triage text correction (GH-1951) — the Legacy detail panel's
diff --git a/frontend/taskdeck-web/src/locales/es/inbox.ts b/frontend/taskdeck-web/src/locales/es/inbox.ts
index e4a631598..5d2f97d31 100644
--- a/frontend/taskdeck-web/src/locales/es/inbox.ts
+++ b/frontend/taskdeck-web/src/locales/es/inbox.ts
@@ -174,18 +174,25 @@ export default {
       state: 'Estado: {label}. Dónde está ahora mismo esta captura.',
       source: 'Origen: {label}. Cómo llegó esta captura — no es un estado.',
     },
-    // Destino de una corrección sin guardar cuya captura sale de la lista
+    // Dónde queda una corrección sin guardar cuya captura sale de la lista
     // (#1999, punto 3): un cambio del filtro de tablero, una recarga que ya no
-    // devuelve la fila, o el paso al historial de solo lectura.
+    // devuelve la fila, o el paso al historial de solo lectura. `{capture}` es
+    // el extracto de la propia fila.
     //
-    // Son RECIBOS, no avisos: cuando se muestran la decisión ya está tomada,
-    // así que cada uno dice qué pasó con la corrección y dónde está ahora.
-    // `{capture}` es el extracto de la propia fila.
+    // `kept` y `discarded` son recibos de un momento. `held`, `blocked` y
+    // `heldUneditable` son frases vigentes mientras se ven, así que cada una
+    // termina diciendo qué puede hacer quien lee.
+    //
+    // `kept` dice "esta lista" a propósito: la corrección vive en la tabla
+    // mientras la tabla exista, y prometerla tras recargar la página sería una
+    // promesa que este mecanismo no puede cumplir.
     draft: {
-      kept: 'La corrección sin guardar de “{capture}” no se ha perdido. Se conserva aquí y vuelve con esa captura cuando reaparezca en esta lista. No se guardó nada.',
-      restored: 'La corrección sin guardar de “{capture}” vuelve a estar en el editor, sobre el texto que la captura tiene ahora. Guárdala o cancela como siempre.',
+      kept: 'La corrección sin guardar de “{capture}” no se ha perdido. Se conserva mientras sigas en esta lista de Inbox y vuelve con esa captura cuando reaparezca. No se guardó nada.',
+      held: 'La corrección sin guardar de “{capture}” sigue conservada. Pulsa Editar captura en esa fila para recuperarla.',
       blocked: 'La corrección sin guardar de “{capture}” sigue conservada. Otra captura está abierta para editar: termina esa y luego pulsa Editar captura en esta fila para recuperarla.',
-      discarded: 'La corrección sin guardar de “{capture}” se descartó: la captura ahora está {status} y su texto ya no se puede editar aquí. No se guardó nada.',
+      heldUneditable: 'La corrección sin guardar de “{capture}” sigue conservada. Esta lista no edita una captura que está {status}, así que la corrección espera aquí hasta que esa captura vuelva a poder editarse.',
+      restored: 'La corrección sin guardar de “{capture}” vuelve a estar en el editor, sobre la captura tal como está ahora. Guárdala o cancela como siempre.',
+      discarded: 'La corrección sin guardar de “{capture}” se descartó: la captura ahora está {status} y su texto ya no se puede editar. No se guardó nada.',
       dismiss: 'Descartar estos avisos',
     },
     // Corrección del texto antes de clasificar (GH-1951).
diff --git a/frontend/taskdeck-web/src/locales/it/inbox.ts b/frontend/taskdeck-web/src/locales/it/inbox.ts
index f85a9f515..b9b819821 100644
--- a/frontend/taskdeck-web/src/locales/it/inbox.ts
+++ b/frontend/taskdeck-web/src/locales/it/inbox.ts
@@ -171,19 +171,25 @@ export default {
       state: 'Stato: {label}. Il punto in cui si trova ora questa cattura.',
       source: 'Origine: {label}. Come è arrivata questa cattura — non è uno stato.',
     },
-    // Destino di una correzione non salvata la cui cattura esce dall'elenco
+    // Dove resta una correzione non salvata la cui cattura esce dall'elenco
     // (#1999, punto 3): un cambio del filtro bacheca, un aggiornamento che non
     // restituisce più la riga, oppure il passaggio allo storico in sola
-    // lettura.
+    // lettura. `{capture}` è l'estratto della riga stessa.
     //
-    // Sono RICEVUTE, non avvisi: quando compaiono la decisione è già presa, e
-    // ognuna dice che fine ha fatto la correzione e dov'è adesso.
-    // `{capture}` è l'estratto della riga stessa.
+    // `kept` e `discarded` sono ricevute di un momento. `held`, `blocked` e
+    // `heldUneditable` sono frasi valide finché restano a schermo, quindi
+    // ognuna finisce dicendo che cosa può fare chi legge.
+    //
+    // `kept` dice "questo elenco" di proposito: la correzione vive nella
+    // tabella finché la tabella esiste, e prometterla dopo un ricaricamento
+    // sarebbe una promessa che questo meccanismo non può mantenere.
     draft: {
-      kept: 'La correzione non salvata di “{capture}” non è andata persa. Resta conservata qui e torna con quella cattura quando ricompare in questo elenco. Non è stato salvato nulla.',
-      restored: 'La correzione non salvata di “{capture}” è di nuovo nell\'editor, sopra il testo che la cattura ha ora. Salvala o annulla come sempre.',
-      blocked: 'La correzione non salvata di “{capture}” resta conservata. Un\'altra cattura è aperta in modifica: concludi quella, poi premi Modifica cattura su questa riga per riprenderla.',
-      discarded: 'La correzione non salvata di “{capture}” è stata scartata: la cattura ora è {status} e il suo testo non è più modificabile qui. Non è stato salvato nulla.',
+      kept: 'La correzione non salvata di “{capture}” non è andata persa. Resta conservata finché rimani su questo elenco Inbox e torna con quella cattura quando ricompare. Non è stato salvato nulla.',
+      held: 'La correzione non salvata di “{capture}” è ancora conservata. Premi Modifica cattura su quella riga per riprenderla.',
+      blocked: 'La correzione non salvata di “{capture}” è ancora conservata. Un\'altra cattura è aperta in modifica: concludi quella, poi premi Modifica cattura su questa riga per riprenderla.',
+      heldUneditable: 'La correzione non salvata di “{capture}” è ancora conservata. Questo elenco non modifica una cattura che è {status}, quindi la correzione resta qui finché quella cattura non torna modificabile.',
+      restored: 'La correzione non salvata di “{capture}” è di nuovo nell\'editor, sopra la cattura così com\'è ora. Salvala o annulla come sempre.',
+      discarded: 'La correzione non salvata di “{capture}” è stata scartata: la cattura ora è {status} e il suo testo non è più modificabile. Non è stato salvato nulla.',
       dismiss: 'Chiudi queste note',
     },
     // Correzione del testo prima dello smistamento (GH-1951).
diff --git a/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageRowEdit.spec.ts b/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageRowEdit.spec.ts
index 4c86fdca9..5b26af607 100644
--- a/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageRowEdit.spec.ts
+++ b/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageRowEdit.spec.ts
@@ -421,7 +421,7 @@ describe('PaperTriageRowEdit', () => {
 
   // ── the draft hand-off, so a row that leaves the list can keep it (#1999) ──
 
-  it('hands out the unsaved draft, and nothing while there is nothing unsaved', async () => {
+  it('reports only the fields the user changed, and an empty draft when none are', async () => {
     mockCaptureStore.fetchDetail.mockResolvedValue(
       makeDetail({ metadata: { dueDate: '2026-05-01', labels: ['ops'] } }),
     )
@@ -429,21 +429,31 @@ describe('PaperTriageRowEdit', () => {
 
     // An opened-but-untouched editor holds no correction; saying otherwise
     // would have the table announce a loss that did not happen.
-    expect(wrapper.vm.readDraft()).toBeNull()
+    expect(wrapper.vm.readDraft()).toEqual({ state: 'ready', draft: null })
 
     await wrapper.get('[data-testid="capture-edit-textarea"]').setValue('Ship the release notes')
     await wrapper.get('[data-testid="capture-edit-label-input"]').setValue('release')
 
+    // Per field: the untouched due date is absent rather than carried as the
+    // value this load happened to see, so it can never be laid back over a
+    // newer one.
     expect(wrapper.vm.readDraft()).toEqual({
-      text: 'Ship the release notes',
-      dueDate: '2026-05-01',
-      labels: ['ops'],
-      // The uncommitted label box travels too: Save would have flushed it.
-      labelInput: 'release',
+      state: 'ready',
+      draft: {
+        text: 'Ship the release notes',
+        // The uncommitted label box travels too: Save would have flushed it.
+        labelInput: 'release',
+      },
     })
   })
 
-  it('hands out nothing while the capture text has not loaded', async () => {
+  /**
+   * The distinction the whole hand-off rests on: "there is nothing unsaved" and
+   * "I cannot tell" are different answers. Collapsing them into one lets the
+   * table release a held correction while the editor is still loading, has
+   * failed to load, or was refused — none of which is evidence about the draft.
+   */
+  it('reports that it cannot answer while the capture text has not loaded', async () => {
     let resolveDetail: (detail: CaptureItem) => void = () => {}
     mockCaptureStore.fetchDetail.mockImplementation(
       () => new Promise<CaptureItem>((resolve) => { resolveDetail = resolve }),
@@ -451,30 +461,39 @@ describe('PaperTriageRowEdit', () => {
     const wrapper = mount(PaperTriageRowEdit, { props: { itemId: 'capture-1' } })
     await flushPromises()
 
-    // There is no textarea yet, so an empty `draft` is the absence of data and
-    // not an edit — handing it out would let the table keep a blank correction.
-    expect(wrapper.vm.readDraft()).toBeNull()
+    expect(wrapper.vm.readDraft()).toEqual({ state: 'unavailable' })
     resolveDetail(makeDetail())
     await flushPromises()
-    expect(wrapper.vm.readDraft()).toBeNull()
+    expect(wrapper.vm.readDraft()).toEqual({ state: 'ready', draft: null })
+  })
+
+  it('reports that it cannot answer when the load failed', async () => {
+    mockCaptureStore.fetchDetail.mockRejectedValue(new Error('offline'))
+    const wrapper = await mountEditor()
+
+    expect(wrapper.find('[data-testid="capture-edit-load-error"]').exists()).toBe(true)
+    expect(wrapper.vm.readDraft()).toEqual({ state: 'unavailable' })
+  })
+
+  it('reports that it cannot answer when the server refuses the edit', async () => {
+    mockCaptureStore.fetchDetail.mockResolvedValue(makeDetail({ canEditSuggestion: false }))
+    const wrapper = await mountEditor()
+
+    expect(wrapper.find('[data-testid="capture-edit-blocked"]').exists()).toBe(true)
+    expect(wrapper.vm.readDraft()).toEqual({ state: 'unavailable' })
   })
 
   it('restores a kept draft over the server text it re-reads, and says it did', async () => {
     const wrapper = mount(PaperTriageRowEdit, {
       props: {
         itemId: 'capture-1',
-        restoredDraft: {
-          text: 'Ship the release notes before Friday',
-          dueDate: '',
-          labels: [],
-          labelInput: '',
-        },
+        restoredDraft: { text: 'Ship the release notes before Friday' },
       },
     })
     await flushPromises()
 
-    // The fetch still happens: the ORIGINAL the draft is compared against has
-    // to be the capture's current text, not the one it had when it left.
+    // The fetch still happens: the values the draft is laid over have to be the
+    // capture's current ones, not the ones it had when it left.
     expect(mockCaptureStore.fetchDetail).toHaveBeenCalledWith(
       'capture-1',
       expect.objectContaining({ forceRefresh: true }),
@@ -488,12 +507,40 @@ describe('PaperTriageRowEdit', () => {
     expect(wrapper.get('button[data-action="edit-save"]').attributes('disabled')).toBeUndefined()
   })
 
+  it('lays only the changed fields over the values it re-reads, so a Save cannot revert the rest', async () => {
+    // The capture's metadata moved on the server while the correction was held.
+    // The user only ever touched the text.
+    mockCaptureStore.fetchDetail.mockResolvedValue(
+      makeDetail({ metadata: { dueDate: '2026-06-01', labels: ['ops'] } }),
+    )
+    const wrapper = mount(PaperTriageRowEdit, {
+      props: {
+        itemId: 'capture-1',
+        restoredDraft: { text: 'Ship the release notes before Friday' },
+      },
+    })
+    await flushPromises()
+
+    expect(wrapper.get<HTMLInputElement>('[data-testid="capture-edit-due-date"]').element.value)
+      .toBe('2026-06-01')
+    expect(wrapper.get('[data-testid="capture-edit-label-chip"]').text()).toContain('ops')
+
+    await wrapper.get('button[data-action="edit-save"]').trigger('click')
+    await flushPromises()
+
+    // No metadata block at all: nothing the user touched was metadata, so the
+    // server's own due date and labels are left exactly where they are.
+    expect(mockCaptureStore.updateSuggestion).toHaveBeenCalledWith('capture-1', {
+      text: 'Ship the release notes before Friday',
+    })
+  })
+
   it('does not restore a draft into a capture the server refuses to edit', async () => {
     mockCaptureStore.fetchDetail.mockResolvedValue(makeDetail({ canEditSuggestion: false }))
     const wrapper = mount(PaperTriageRowEdit, {
       props: {
         itemId: 'capture-1',
-        restoredDraft: { text: 'a correction with nowhere to land', dueDate: '', labels: [], labelInput: '' },
+        restoredDraft: { text: 'a correction with nowhere to land' },
       },
     })
     await flushPromises()
diff --git a/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageTable.spec.ts b/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageTable.spec.ts
index 812d82acc..7c993c6ba 100644
--- a/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageTable.spec.ts
+++ b/frontend/taskdeck-web/src/tests/views/paper/inbox/PaperTriageTable.spec.ts
@@ -1104,6 +1104,7 @@ describe('PaperTriageTable', () => {
     expect(wrapper.get('button[data-action="edit-save"]').attributes('disabled')).toBeDefined()
   })
 
+
   // --- draft fate when the edited row leaves the list (#1999 item 3) --------
 
   /**
@@ -1118,7 +1119,21 @@ describe('PaperTriageTable', () => {
    * inbox for the new scope and a new `items` array arrives. A same-scope
    * refresh that drops the row reaches the table through exactly the same
    * prop, which is why one case covers both.
+   *
+   * Restoring is the user's move, never the table's: a held correction comes
+   * back only through Edit capture on its row. The notices region says the
+   * correction is there to come back to.
    */
+  function noticeKinds(wrapper: ReturnType<typeof mount>): string[] {
+    return wrapper
+      .findAll('[data-testid="capture-draft-notices"] p')
+      .map((line) => line.attributes('data-notice') ?? '')
+  }
+
+  function noticeFor(wrapper: ReturnType<typeof mount>, kind: string) {
+    return wrapper.get(`[data-testid="capture-draft-notices"] p[data-notice="${kind}"]`)
+  }
+
   async function openEditorAndType(
     wrapper: ReturnType<typeof mount>,
     rowIndex: number,
@@ -1130,9 +1145,22 @@ describe('PaperTriageTable', () => {
     return text
   }
 
+  it('mounts the notices region before it has anything to say', () => {
+    // A live region inserted at the same moment its text appears is announced
+    // unreliably (#2593/#2630). It is mounted and silent instead, so a notice
+    // is a mutation of a region that was already there.
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    const region = wrapper.get('[data-testid="capture-draft-notices"]')
+
+    expect(region.attributes('role')).toBe('status')
+    expect(region.attributes('aria-live')).toBe('polite')
+    expect(region.text()).toBe('')
+    expect(noticeKinds(wrapper)).toEqual([])
+  })
+
   it('keeps an unsaved correction and names the capture when its row leaves the list', async () => {
     const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
-    const typed = await openEditorAndType(wrapper, 0, 'a correction the filter change must not eat')
+    await openEditorAndType(wrapper, 0, 'a correction the filter change must not eat')
 
     await wrapper.setProps({ items: makeItems().slice(1) })
     await flushPromises()
@@ -1140,19 +1168,16 @@ describe('PaperTriageTable', () => {
     // The editor still closes — the row it belongs to is gone.
     expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(false)
 
-    const notices = wrapper.get('[data-testid="capture-draft-notices"]')
-    expect(notices.attributes('role')).toBe('status')
-    const kept = notices.get('[data-notice="kept"]')
+    const kept = noticeFor(wrapper, 'kept')
     // Named by the same excerpt the row shows, so the user knows WHICH capture.
     expect(kept.text()).toContain('First excerpt')
-    expect(kept.text()).toContain('comes back')
+    expect(kept.text()).toContain('this Inbox list')
 
     // Nothing was written anywhere: this is component state, not a save.
     expect(mockCaptureStore.updateSuggestion).not.toHaveBeenCalled()
     expect(wrapper.emitted('accept')).toBeUndefined()
     expect(wrapper.emitted('keep')).toBeUndefined()
     expect(wrapper.emitted('reject')).toBeUndefined()
-    expect(typed.length).toBeGreaterThan(0)
   })
 
   it('says nothing and keeps nothing when the row leaves with an untouched editor', async () => {
@@ -1165,10 +1190,10 @@ describe('PaperTriageTable', () => {
     await wrapper.setProps({ items: makeItems().slice(1) })
     await flushPromises()
 
-    expect(wrapper.find('[data-testid="capture-draft-notices"]').exists()).toBe(false)
+    expect(noticeKinds(wrapper)).toEqual([])
   })
 
-  it('restores the kept correction when the capture returns to the list', async () => {
+  it('offers a held correction back on the returning row, and restores it on Edit', async () => {
     const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
     const typed = await openEditorAndType(wrapper, 0, 'the correction that has to survive the round trip')
 
@@ -1177,19 +1202,26 @@ describe('PaperTriageTable', () => {
     await wrapper.setProps({ items: makeItems() })
     await flushPromises()
 
-    const rows = wrapper.findAll('.paper-triage__row')
-    expect(rows[0].find('[data-testid="capture-edit"]').exists()).toBe(true)
+    // No editor opens by itself: restoring is an explicit action, like every
+    // other write-adjacent move on this surface.
+    expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(false)
+    const held = noticeFor(wrapper, 'held')
+    expect(held.text()).toContain('First excerpt')
+    expect(held.text()).toContain('Edit capture')
+
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+
     expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
       .toBe(typed)
-    expect(wrapper.get('[data-testid="capture-draft-notices"]').get('[data-notice="restored"]').text())
-      .toContain('First excerpt')
+    expect(noticeFor(wrapper, 'restored').text()).toContain('First excerpt')
     // The server's current text is re-read on the way back in, so the draft is
     // measured against what the capture says NOW, not what it said before.
     expect(mockCaptureStore.fetchDetail).toHaveBeenCalledTimes(2)
     expect(mockCaptureStore.updateSuggestion).not.toHaveBeenCalled()
   })
 
-  it('refuses a second editor when the capture returns, and keeps the correction', async () => {
+  it('holds the correction while another editor is open, and says that is why', async () => {
     const items = makeItems()
     items[1] = { ...items[1], status: 'New' }
     const wrapper = mount(PaperTriageTable, { props: { items } })
@@ -1210,41 +1242,180 @@ describe('PaperTriageTable', () => {
     expect(wrapper.findAll('[data-testid="capture-edit"]')).toHaveLength(1)
     expect(rows[1].find('[data-testid="capture-edit"]').exists()).toBe(true)
     expect(rows[0].find('[data-testid="capture-edit"]').exists()).toBe(false)
-    expect(wrapper.get('[data-testid="capture-draft-notices"]').get('[data-notice="blocked"]').text())
-      .toContain('First excerpt')
+    const blocked = noticeFor(wrapper, 'blocked')
+    expect(blocked.text()).toContain('First excerpt')
 
-    // Still kept: closing the open editor and asking for capture-1 brings it back.
+    // Still held: closing the open editor and asking for capture-1 brings it back.
     await wrapper.get('button[data-action="edit-cancel"]').trigger('click')
     await flushPromises()
+    expect(noticeKinds(wrapper)).toContain('held')
+
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+    expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
+      .toBe(typed)
+  })
+
+  /**
+   * The editor can be open without being able to say anything about a draft:
+   * loading, failed, or refused by the server. Treating that silence as
+   * "nothing unsaved" released the held correction, so the second filter change
+   * in this test used to destroy it — the same silent loss, one layer in.
+   */
+  it('keeps a correction whose editor could not load before the list changed again', async () => {
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    const typed = await openEditorAndType(wrapper, 0, 'a correction behind a failing read')
+
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+    await wrapper.setProps({ items: makeItems() })
+    await flushPromises()
+
+    // Restoring it hits a detail read that fails, so the editor can say nothing.
+    mockCaptureStore.fetchDetail.mockRejectedValueOnce(new Error('offline'))
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+    expect(wrapper.find('[data-testid="capture-edit-load-error"]').exists()).toBe(true)
+
+    // The filter changes again while that error panel is open.
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+    expect(noticeFor(wrapper, 'kept').text()).toContain('First excerpt')
+
+    // The correction survived: it is offered back, and it comes back.
+    await wrapper.setProps({ items: makeItems() })
+    await flushPromises()
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+    expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
+      .toBe(typed)
+  })
+
+  it('keeps a correction when the reader closes an editor that failed to load', async () => {
+    // Cancel on the error panel answers the failed READ. The user never saw the
+    // correction, so it cannot be their answer to it.
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    const typed = await openEditorAndType(wrapper, 0, 'a correction the reader never got to see')
+
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+    await wrapper.setProps({ items: makeItems() })
+    await flushPromises()
+
+    mockCaptureStore.fetchDetail.mockRejectedValueOnce(new Error('offline'))
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+    await wrapper.get('[data-testid="capture-edit-load-error"] button[data-action="edit-cancel"]')
+      .trigger('click')
+    await flushPromises()
+
+    expect(noticeKinds(wrapper)).toContain('held')
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+    expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
+      .toBe(typed)
+  })
+
+  it('keeps a correction when the reader closes an editor the server refused', async () => {
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    const typed = await openEditorAndType(wrapper, 0, 'a correction behind a refused edit')
+
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+    await wrapper.setProps({ items: makeItems() })
+    await flushPromises()
+
+    // The server answers "not editable" this time — a transcript-linked capture
+    // reads that way whatever its status.
+    mockCaptureStore.fetchDetail.mockResolvedValueOnce({
+      id: 'capture-1',
+      userId: 'user-1',
+      boardId: 'board-alpha',
+      status: 'New',
+      source: 'Typed',
+      textExcerpt: 'First excerpt',
+      rawText: 'First excerpt in full',
+      createdAt: new Date('2026-04-25T09:42:00Z').toISOString(),
+      processedAt: null,
+      retryCount: 0,
+      provenance: null,
+      canEditSuggestion: false,
+    })
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+    await wrapper.get('[data-testid="capture-edit-blocked"] button[data-action="edit-cancel"]')
+      .trigger('click')
+    await flushPromises()
+
+    expect(noticeKinds(wrapper)).toContain('held')
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+    expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
+      .toBe(typed)
+  })
+
+  /**
+   * Editability for the DISCARD decision is the server's rule
+   * (`CaptureService.IsSuggestionEditableStatus`: New, Failed, Triaged), never
+   * this list's action gate. Dropping a correction is irreversible, so it may
+   * not be keyed on a client-side product policy that a ruling could change,
+   * and never on a status the capture is only passing through.
+   */
+  // `Triaged` is a capture this list will not edit under the current gate;
+  // `Triaging` is one it is only passing through. Neither is the server saying
+  // no, so neither may cost the reader their correction.
+  it.each(['Triaged', 'Triaging'] as const)('keeps a correction whose capture comes back %s, and says why', async (status) => {
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    const typed = await openEditorAndType(wrapper, 0, 'a correction for a capture that moved on')
+
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+
+    const returned = makeItems()
+    returned[0] = { ...returned[0], status: status as CaptureStatusValue }
+    await wrapper.setProps({ items: returned })
+    await flushPromises()
+
+    expect(noticeKinds(wrapper)).not.toContain('discarded')
+    const held = noticeFor(wrapper, 'heldUneditable')
+    expect(held.text()).toContain('First excerpt')
+    expect(held.text()).toContain(status)
+
+    // And it really is still there once the capture is editable again.
+    await wrapper.setProps({ items: makeItems() })
+    await flushPromises()
     await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
     await flushPromises()
     expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
       .toBe(typed)
   })
 
-  it('drops a kept correction with a stated reason once the capture is no longer editable', async () => {
+  it.each([
+    ['ProposalCreated', 'Ready for review'],
+    ['Converted', 'Applied to board'],
+    ['Ignored', 'Ignored'],
+  ] as const)('drops a correction with a stated reason once the capture is %s', async (status, label) => {
     const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
-    await openEditorAndType(wrapper, 0, 'a correction for a capture that moved on')
+    await openEditorAndType(wrapper, 0, 'a correction with nowhere left to land')
 
     await wrapper.setProps({ items: makeItems().slice(1) })
     await flushPromises()
 
-    // capture-1 comes back Triaged: the surface can no longer edit it, so the
-    // correction has nowhere to go and is dropped — with a receipt.
-    const triaged = makeItems()
-    triaged[0] = { ...triaged[0], status: 'Triaged' }
-    await wrapper.setProps({ items: triaged })
+    // These are the settled states the server itself would refuse a text edit
+    // in, so the correction can never be applied and holding it would be a
+    // promise this surface cannot keep.
+    const returned = makeItems()
+    returned[0] = { ...returned[0], status: status as CaptureStatusValue }
+    await wrapper.setProps({ items: returned })
     await flushPromises()
 
-    const discarded = wrapper.get('[data-testid="capture-draft-notices"]').get('[data-notice="discarded"]')
+    const discarded = noticeFor(wrapper, 'discarded')
     expect(discarded.text()).toContain('First excerpt')
-    expect(discarded.text()).toContain('Triaged')
-    expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(false)
+    expect(discarded.text()).toContain(label)
 
     // And it is really gone: an editable capture-1 later opens on server text.
     await wrapper.setProps({ items: makeItems() })
     await flushPromises()
-    expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(false)
     await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
     await flushPromises()
     expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
@@ -1252,6 +1423,56 @@ describe('PaperTriageTable', () => {
     expect(mockCaptureStore.updateSuggestion).not.toHaveBeenCalled()
   })
 
+  it('never announces a discard for a capture the reader has open', async () => {
+    // The correction is on screen in the textarea. Announcing that it was
+    // dropped would be false, and dropping it would take what the user is
+    // looking at.
+    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
+    const typed = await openEditorAndType(wrapper, 0, 'a correction being read right now')
+
+    await wrapper.setProps({ items: makeItems().slice(1) })
+    await flushPromises()
+    await wrapper.setProps({ items: makeItems() })
+    await flushPromises()
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+
+    const converted = makeItems()
+    converted[0] = { ...converted[0], status: 'Converted' }
+    await wrapper.setProps({ items: converted })
+    await flushPromises()
+
+    expect(noticeKinds(wrapper)).not.toContain('discarded')
+    expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
+      .toBe(typed)
+  })
+
+  it('carries one line per capture, so one correction never speaks over another', async () => {
+    const items = makeItems()
+    items[1] = { ...items[1], status: 'New' }
+    const wrapper = mount(PaperTriageTable, { props: { items } })
+
+    await openEditorAndType(wrapper, 0, 'the first correction')
+    await wrapper.setProps({ items: items.slice(1) })
+    await flushPromises()
+    await openEditorAndType(wrapper, 0, 'the second correction')
+    await wrapper.setProps({ items: [] })
+    await flushPromises()
+
+    // One list change settles both: capture-1 is past editing, capture-2 is not.
+    const returned = [{ ...items[0], status: 'Converted' as CaptureStatusValue }, items[1]]
+    await wrapper.setProps({ items: returned })
+    await flushPromises()
+    expect(noticeKinds(wrapper).sort()).toEqual(['discarded', 'held'])
+
+    // Restoring capture-2 must not take capture-1's receipt off the surface.
+    await wrapper.findAll('button[data-action="edit"]')[1].trigger('click')
+    await flushPromises()
+    expect(noticeKinds(wrapper).sort()).toEqual(['discarded', 'restored'])
+    expect(noticeFor(wrapper, 'discarded').text()).toContain('First excerpt')
+    expect(noticeFor(wrapper, 'restored').text()).toContain('Second excerpt')
+  })
+
   it('does not drop a kept correction merely because the list changed again', async () => {
     const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
     const typed = await openEditorAndType(wrapper, 0, 'a correction that outlives two filter changes')
@@ -1265,6 +1486,8 @@ describe('PaperTriageTable', () => {
     await wrapper.setProps({ items: makeItems() })
     await flushPromises()
 
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
     expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
       .toBe(typed)
   })
@@ -1279,24 +1502,36 @@ describe('PaperTriageTable', () => {
     await flushPromises()
 
     expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(false)
-    expect(wrapper.get('[data-testid="capture-draft-notices"]').get('[data-notice="kept"]').text())
-      .toContain('First excerpt')
+    expect(noticeFor(wrapper, 'kept').text()).toContain('First excerpt')
   })
 
-  it('lets the reader dismiss the draft receipt', async () => {
-    const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
-    await openEditorAndType(wrapper, 0, 'a correction whose receipt has been read')
+  it('lets the reader dismiss the receipts and leaves focus on the region', async () => {
+    const wrapper = mount(PaperTriageTable, {
+      props: { items: makeItems() },
+      attachTo: document.body,
+    })
+    try {
+      await openEditorAndType(wrapper, 0, 'a correction whose receipt has been read')
 
-    await wrapper.setProps({ items: makeItems().slice(1) })
-    await flushPromises()
+      await wrapper.setProps({ items: makeItems().slice(1) })
+      await flushPromises()
+      expect(noticeKinds(wrapper)).toEqual(['kept'])
+
+      await wrapper.get('button[data-action="dismiss-draft-notice"]').trigger('click')
+      await flushPromises()
 
-    await wrapper.get('button[data-action="dismiss-draft-notice"]').trigger('click')
-    expect(wrapper.find('[data-testid="capture-draft-notices"]').exists()).toBe(false)
+      const region = wrapper.get('[data-testid="capture-draft-notices"]')
+      // The region stays mounted; only what it was saying goes away.
+      expect(noticeKinds(wrapper)).toEqual([])
+      expect(document.activeElement).toBe(region.element)
+    } finally {
+      wrapper.unmount()
+    }
   })
 
-  it('forgets the correction when the user cancels the restored edit', async () => {
-    // Cancel still means cancel: the kept copy is not a second life for text
-    // the user has explicitly abandoned.
+  it('forgets the correction when the user cancels a loaded edit', async () => {
+    // Cancel still means cancel: the held copy is not a second life for text
+    // the user has explicitly abandoned in an editor they could see.
     const wrapper = mount(PaperTriageTable, { props: { items: makeItems() } })
     await openEditorAndType(wrapper, 0, 'a correction the user changed their mind about')
 
@@ -1304,14 +1539,16 @@ describe('PaperTriageTable', () => {
     await flushPromises()
     await wrapper.setProps({ items: makeItems() })
     await flushPromises()
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
 
     await wrapper.get('button[data-action="edit-cancel"]').trigger('click')
     await flushPromises()
-    await wrapper.setProps({ items: makeItems().slice(1) })
-    await flushPromises()
-    await wrapper.setProps({ items: makeItems() })
-    await flushPromises()
 
-    expect(wrapper.find('[data-testid="capture-edit"]').exists()).toBe(false)
+    expect(noticeKinds(wrapper)).toEqual([])
+    await wrapper.findAll('button[data-action="edit"]')[0].trigger('click')
+    await flushPromises()
+    expect(wrapper.get<HTMLTextAreaElement>('[data-testid="capture-edit-textarea"]').element.value)
+      .toBe('First excerpt in full')
   })
 })
diff --git a/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageRowEdit.vue b/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageRowEdit.vue
index c9ef660b5..dad78f4a3 100644
--- a/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageRowEdit.vue
+++ b/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageRowEdit.vue
@@ -3,22 +3,41 @@
  * One editor's unsaved correction, in the shape `PaperTriageTable` holds while
  * the capture is off the list and hands back when it returns (#1999 item 3).
  *
- * It is deliberately the DRAFT side only — the server's own text, due date and
- * labels are re-read on the way back in, so a kept correction is always
- * measured against what the capture says now rather than what it said when the
- * board filter changed. `labelInput` travels with the rest because Save
- * flushes it into the payload: leaving it behind would silently drop a label
- * the user had typed but not yet committed with Enter.
+ * Every field is OPTIONAL and present only when the user actually changed it.
+ * That is the whole point: the server's text, due date and labels are re-read
+ * on the way back in, and only the changed fields are laid over them. Carrying
+ * an untouched field would carry the value the OLD load happened to see, and
+ * laying that back over a newer one would revert, on the next Save, a due date
+ * or a label the user never touched.
+ *
+ * `labelInput` travels with the rest because Save flushes it into the payload:
+ * leaving it behind would silently drop a label the user had typed but not yet
+ * committed with Enter.
  *
  * Exported from a plain `<script>` block so the table can name the type it is
  * holding; `<script setup>` cannot export.
  */
 export type PaperTriageDraft = {
-  text: string
-  dueDate: string
-  labels: string[]
-  labelInput: string
+  text?: string
+  dueDate?: string
+  labels?: string[]
+  labelInput?: string
 }
+
+/**
+ * What the editor can say about its draft right now.
+ *
+ * `unavailable` and `{ ready, draft: null }` are deliberately different
+ * answers, and conflating them is a data-loss bug: only the second is evidence
+ * that there is nothing unsaved. While the capture text is still loading, or
+ * the read failed, or the server refused the edit, this editor has never shown
+ * the user a textarea and knows nothing about any correction the table may be
+ * holding for the row — so it says so, and the table leaves what it holds
+ * alone.
+ */
+export type PaperTriageDraftReport =
+  | { state: 'ready'; draft: PaperTriageDraft | null }
+  | { state: 'unavailable' }
 </script>
 
 <script setup lang="ts">
@@ -211,7 +230,7 @@ watch([draft, dueDateDraft, labelsDraft], () => {
 })
 
 /**
- * Put a kept correction back over the values just read from the server
+ * Put a held correction back over the values just read from the server
  * (#1999 item 3).
  *
  * Called from inside `load`, on the editable path ONLY: the `blocked` and
@@ -219,49 +238,70 @@ watch([draft, dueDateDraft, labelsDraft], () => {
  * edit never gets a textarea seeded with text it would not accept, and the
  * table keeps holding the correction instead.
  *
- * Once, guarded by `restoreApplied` rather than by the prop going null — the
- * table holds the kept copy until the editor is closed explicitly, so a Retry
- * after a failed load still restores, while a second successful load can never
- * overwrite what the user has typed since the first one.
+ * FIELD BY FIELD, and only the fields the user changed. An untouched field
+ * keeps the value this load just returned, so a correction to the text cannot
+ * quietly revert a due date or a label that moved on the server while it was
+ * held. What Save then sends is the current server value for everything the
+ * user left alone — last-write-wins, exactly as an editor opened fresh would
+ * be, with no extra staleness bought by the hold.
  *
- * Metadata is restored only when the server offered metadata this time.
- * `metadataChanged` is gated on the same flag, so seeding a due date or labels
- * the payload cannot carry would put values on screen that Save would drop.
+ * Once, guarded by `restoreApplied` rather than by the prop going null — the
+ * table holds its copy until the editor is closed from a loaded state, so a
+ * Retry after a failed load still restores, while a second successful load can
+ * never overwrite what the user has typed since the first one.
  */
 function applyRestoredDraft() {
   const restored = props.restoredDraft
   if (!restored || restoreApplied.value) return
   restoreApplied.value = true
-  draft.value = restored.text
-  if (metadataAvailable.value) {
+  let applied = false
+  if (restored.text !== undefined) {
+    draft.value = restored.text
+    applied = true
+  }
+  if (restored.dueDate !== undefined) {
     dueDateDraft.value = restored.dueDate
+    applied = true
+  }
+  if (restored.labels !== undefined) {
     labelsDraft.value = [...restored.labels]
+    applied = true
+  }
+  if (restored.labelInput !== undefined) {
     labelInput.value = restored.labelInput
+    applied = true
   }
-  emit('restored', props.itemId)
+  if (applied) emit('restored', props.itemId)
 }
 
 /**
- * The unsaved correction, for the table to hold while this row is off the list
- * (#1999 item 3) — or `null` when there is nothing to hold.
+ * What this editor can say about its unsaved correction, for the table that
+ * may be holding one for this row (#1999 item 3).
  *
  * A getter rather than an emit on unmount, because the table already knows the
- * single moment the close is INVOLUNTARY (its `items` watcher, and the
- * read-only switch) and reads the draft there. `close` fires on Cancel and on
- * a completed Save too, so an unmount emit would make the table infer, from a
- * flag set one line earlier, which kind of close it was — and get Cancel wrong
- * the first time that inference broke.
+ * moments that matter — the row leaving the list, the read-only switch, and
+ * the `close` it just received — and reads the editor there. `close` fires
+ * from four places with two different meanings (Cancel and a landed Save from
+ * a loaded editor; Cancel on the load-error panel and Close on the refused
+ * panel, where the user never saw a draft at all), so an unmount emit would
+ * make the table infer intent from a flag rather than ask.
+ *
+ * `unavailable` outside the `ready` state is the load-bearing part: the table
+ * must not read silence as "nothing unsaved" and release what it holds.
  *
- * Only offered from the `ready` state: before the text lands there is no
- * textarea, and an empty `draft` there is the absence of data, not an edit.
+ * The reported draft carries only the fields that differ from what this load
+ * returned, so it is a set of CHANGES rather than a snapshot.
  */
-function readDraft(): PaperTriageDraft | null {
-  if (loadState.value !== 'ready' || !isDirty.value) return null
+function readDraft(): PaperTriageDraftReport {
+  if (loadState.value !== 'ready') return { state: 'unavailable' }
+  const changed: PaperTriageDraft = {}
+  if (draft.value !== originalText.value) changed.text = draft.value
+  if (dueDateDraft.value !== originalDueDate.value) changed.dueDate = dueDateDraft.value
+  if (!labelsEqual(labelsDraft.value, originalLabels.value)) changed.labels = [...labelsDraft.value]
+  if (normalizedLabelInput.value.length > 0) changed.labelInput = labelInput.value
   return {
-    text: draft.value,
-    dueDate: dueDateDraft.value,
-    labels: [...labelsDraft.value],
-    labelInput: labelInput.value,
+    state: 'ready',
+    draft: Object.keys(changed).length > 0 ? changed : null,
   }
 }
 
diff --git a/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageTable.vue b/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageTable.vue
index b0434048c..7e4ca0297 100644
--- a/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageTable.vue
+++ b/frontend/taskdeck-web/src/views/paper/inbox/PaperTriageTable.vue
@@ -3,7 +3,10 @@ import { computed, nextTick, onMounted, ref, shallowRef, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import PaperHLBtn from '../../../components/paper/PaperHLBtn.vue'
 import PaperTagstamp from '../../../components/paper/PaperTagstamp.vue'
-import PaperTriageRowEdit, { type PaperTriageDraft } from './PaperTriageRowEdit.vue'
+import PaperTriageRowEdit, {
+  type PaperTriageDraft,
+  type PaperTriageDraftReport,
+} from './PaperTriageRowEdit.vue'
 import { useBoardStore } from '../../../store/boardStore'
 import {
   canMutateSelection,
@@ -144,33 +147,72 @@ type KeptDraft = { itemId: string; label: string; draft: PaperTriageDraft }
 const keptDrafts = ref(new Map<string, KeptDraft>())
 
 /**
- * What just happened to a kept correction, in the surface's own receipt idiom.
+ * What the notices region says, and the rule for what stands there (#1999).
  *
- * A list rather than one slot because a single list replacement can settle more
- * than one correction's fate — a capture returning uneditable while another
- * row's editor is being closed. Dropping either notice would make the surface
- * silent about exactly the case it exists to narrate. The next run that has
- * something to say replaces the whole list; a run with nothing to say leaves
- * the standing notes alone, and the reader can dismiss them.
+ * ONE LINE PER CAPTURE, and lines for different captures never displace each
+ * other: a receipt saying one correction was dropped cannot be wiped by
+ * another correction coming back in the same list change.
+ *
+ * Two kinds of line, with deliberately different lifetimes.
+ *
+ * STANDING lines (`held`, `blocked`, `heldUneditable`) are DERIVED from the
+ * current state rather than pushed by an event. While a correction is held and
+ * its capture is on this list, the line is recomputed from `items`,
+ * `keptDrafts` and the open editor, so it is always true, it states itself for
+ * every capture that qualifies (never just the last one, never a missed
+ * second), and it disappears on its own the moment it stops being true. They
+ * are not dismissable: they are the current situation, not news.
+ *
+ * RECEIPTS (`kept`, `restored`, `discarded`) record something that happened at
+ * a moment. One per capture, replaced by that capture's next receipt, cleared
+ * when the edit they describe ends from a loaded editor, and dismissable. A
+ * capture with a standing line shows that instead — the current truth outranks
+ * the history.
  */
-type DraftNoticeKind = 'kept' | 'restored' | 'blocked' | 'discarded'
-type DraftNotice = { key: string; kind: DraftNoticeKind; capture: string; status: string }
-const draftNotices = ref<DraftNotice[]>([])
-let draftNoticeSeq = 0
+type DraftLineKind = 'kept' | 'restored' | 'discarded' | 'held' | 'blocked' | 'heldUneditable'
+type DraftLine = {
+  captureId: string
+  kind: DraftLineKind
+  capture: string
+  status: string
+  dismissable: boolean
+}
+const draftReceipts = ref(new Map<string, DraftLine>())
 
-function draftNotice(kind: DraftNoticeKind, capture: string, status = ''): DraftNotice {
-  draftNoticeSeq += 1
-  return { key: `${kind}:${draftNoticeSeq}`, kind, capture, status }
+function setReceipt(
+  kind: 'kept' | 'restored' | 'discarded',
+  captureId: string,
+  capture: string,
+  status = '',
+) {
+  draftReceipts.value.set(captureId, { captureId, kind, capture, status, dismissable: true })
 }
 
-function dismissDraftNotices() {
-  draftNotices.value = []
+/**
+ * Statuses in which the SERVER itself would refuse a text edit.
+ *
+ * `CaptureService.IsSuggestionEditableStatus` allows New, Failed and Triaged,
+ * and `Triaging` is a transient the capture is only passing through — so the
+ * settled refusals are exactly these three. A held correction is dropped for
+ * one of them and nothing else.
+ *
+ * Deliberately NOT this list's own `canMutate` gate: dropping a correction is
+ * irreversible, and that gate is a product policy (#1999 item 2, the D-13
+ * ruling on editing Triaged rows) which a decision can move. A Triaged capture
+ * keeps its correction and says the list will not edit it; only the server's
+ * settled no drops one. An out-of-contract status is not in the set either:
+ * the conservative answer to "I do not recognise this" is to keep.
+ */
+function isPastEditing(status: CaptureStatusValue): boolean {
+  return status === 3 || status === 'ProposalCreated' ||
+    status === 4 || status === 'Converted' ||
+    status === 5 || status === 'Ignored'
 }
 
 /**
  * The capture as this list names it. The excerpt is what the row shows, so the
- * receipt and the row agree; the id is the fallback the open button already
- * uses when there is nothing else to say.
+ * line and the row agree; the id is the fallback the open button already uses
+ * when there is nothing else to say.
  */
 function captureLabel(item: CaptureItemSummary): string {
   const excerpt = typeof item.textExcerpt === 'string' ? item.textExcerpt.trim() : ''
@@ -182,25 +224,93 @@ function restoredDraftFor(item: CaptureItemSummary): PaperTriageDraft | null {
 }
 
 /**
- * Take the open editor's unsaved correction into the kept map before the editor
- * goes away, and answer with the receipt that says so — or `null` when there
- * was nothing unsaved to take.
+ * Why a held correction is not simply being offered back right now: another
+ * editor owns the single slot, or this list will not edit the capture in the
+ * state it is in (a Triaged row under the current gate, or one still being
+ * triaged).
+ */
+function standingLineKind(item: CaptureItemSummary): DraftLineKind {
+  if (editItemId.value !== null) return 'blocked'
+  return canMutate(item) ? 'held' : 'heldUneditable'
+}
+
+const draftNoticeLines = computed<DraftLine[]>(() => {
+  const lines: DraftLine[] = []
+  const standing = new Set<string>()
+  // Archived history has no Edit affordance to point at, so it carries the
+  // receipts only; nothing there invites the reader to bring a correction back.
+  if (!props.readOnly) {
+    for (const item of props.items) {
+      const kept = keptDrafts.value.get(item.id)
+      // A capture whose editor is open needs no line: the correction is either
+      // in the textarea or about to be, in front of the reader.
+      if (!kept || editItemId.value === item.id) continue
+      standing.add(item.id)
+      lines.push({
+        captureId: item.id,
+        kind: standingLineKind(item),
+        capture: kept.label,
+        status: statusLabel(item.status),
+        dismissable: false,
+      })
+    }
+  }
+  for (const receipt of draftReceipts.value.values()) {
+    if (standing.has(receipt.captureId)) continue
+    lines.push(receipt)
+  }
+  return lines
+})
+
+const hasDismissableNotice = computed(() => draftNoticeLines.value.some((line) => line.dismissable))
+
+/**
+ * Dismiss the receipts. Standing lines are untouched, because they describe
+ * corrections that are still held — dismissing those would be the surface
+ * forgetting out loud.
  *
- * The stale-entry delete matters: a restored correction the user has since
- * typed back to the server's own text is no longer a correction, and leaving
- * the old copy in the map would resurrect it on the next return.
+ * Focus moves to the region itself, which stays mounted: the same rule
+ * `closeLoadingDetail` follows, so removing what the reader was on does not
+ * drop focus to the document.
  */
-function keepOpenDraft(): DraftNotice | null {
+async function dismissDraftNotices(event: MouseEvent) {
+  const region = (event.currentTarget as HTMLElement | null)
+    ?.closest<HTMLElement>('.paper-triage__draft-notices')
+  draftReceipts.value.clear()
+  await nextTick()
+  region?.focus()
+}
+
+function readOpenEditor(): PaperTriageDraftReport {
+  return openEditorRefs.value[0]?.readDraft() ?? { state: 'unavailable' }
+}
+
+/**
+ * Take the open editor's unsaved correction into the held map before the
+ * editor goes away.
+ *
+ * The three-way answer is the point. `ready` with a draft holds it; `ready`
+ * with none releases what was held, because a correction typed back to the
+ * server's own text is no longer a correction; and `unavailable` — loading,
+ * failed to load, or refused — changes NOTHING, because an editor that never
+ * showed the reader a textarea is no evidence at all about what is held. The
+ * older shape collapsed the last two into `null` and quietly destroyed a
+ * correction whose restore had not finished loading.
+ */
+function keepOpenDraft() {
   const itemId = editItemId.value
-  if (itemId === null) return null
+  if (itemId === null) return
   const label = editItemLabel.value ?? itemId
-  const draft = openEditorRefs.value[0]?.readDraft() ?? null
-  if (draft === null) {
-    keptDrafts.value.delete(itemId)
-    return null
+  const report = readOpenEditor()
+  if (report.state === 'ready') {
+    if (report.draft === null) {
+      keptDrafts.value.delete(itemId)
+      draftReceipts.value.delete(itemId)
+      return
+    }
+    keptDrafts.value.set(itemId, { itemId, label, draft: report.draft })
   }
-  keptDrafts.value.set(itemId, { itemId, label, draft })
-  return draftNotice('kept', label)
+  if (keptDrafts.value.has(itemId)) setReceipt('kept', itemId, label)
 }
 
 /**
@@ -239,64 +349,37 @@ watch(
  * The board filter is not visible from here: switching it makes the
  * orchestrator load the new scope and hand this table a different `items`
  * array, which is also what a refresh that no longer returns the row does. One
- * watcher therefore answers both, and the three outcomes it can reach are all
- * spoken aloud.
+ * watcher therefore answers both.
  *
- * Ordering is deliberate. The discard sweep runs first, so a correction whose
- * capture came back uneditable is settled before anything else; the departure
- * is handled next, because it is the event that produces new held state; and
- * the return is considered last and only when nothing departed in the same
- * run, so a single replacement never both takes a correction away and reopens
- * an editor somewhere else.
+ * It does two things and no more. Nothing here reopens an editor: a held
+ * correction comes back only through the reader's own Edit, so no editor
+ * appears seeded with text nobody asked for, no board pick in progress is
+ * cancelled by a list arriving, and a return that cannot be honoured needs no
+ * silent exception. The offer to bring it back is a standing line, derived
+ * from the current state rather than pushed from here, so it cannot miss a
+ * second correction or go stale.
  */
 watch(
   () => props.items,
-  (rows, previousRows) => {
-    const notices: DraftNotice[] = []
-
-    // A held correction has nowhere to land once its capture leaves the states
-    // this surface can edit. This is the ONLY case where one is dropped, and
-    // the receipt names the status that closed the door. Time passing, or the
-    // filter changing again, never drops one.
+  (rows) => {
+    // A held correction is dropped only when its capture has settled where the
+    // server itself would refuse the edit. A capture whose editor is OPEN is
+    // never swept: the correction is on screen, so announcing it was dropped
+    // would be false, and dropping it would take what the reader is looking at.
     for (const row of rows) {
       const kept = keptDrafts.value.get(row.id)
-      if (!kept || canMutate(row)) continue
+      if (!kept || editItemId.value === row.id || !isPastEditing(row.status)) continue
       keptDrafts.value.delete(row.id)
-      notices.push(draftNotice('discarded', kept.label, statusLabel(row.status)))
+      setReceipt('discarded', row.id, kept.label, statusLabel(row.status))
     }
 
     // The edited row is not in the replacement. The editor still closes — the
     // row it belongs to is gone — but its draft is taken first.
-    const departed = editItemId.value !== null && !rows.some((row) => row.id === editItemId.value)
-    if (departed) {
-      const kept = keepOpenDraft()
+    if (editItemId.value !== null && !rows.some((row) => row.id === editItemId.value)) {
+      keepOpenDraft()
       editItemId.value = null
       editItemLabel.value = null
-      if (kept) notices.push(kept)
-    }
-
-    // A held correction's capture is back. Only a capture that was absent from
-    // the previous list counts as returning: a row that has simply been on
-    // screen all along must not reopen an editor on every refresh.
-    if (!departed) {
-      const previous = new Set((previousRows ?? []).map((row) => row.id))
-      const returning = rows.find((row) => keptDrafts.value.has(row.id) && !previous.has(row.id))
-      if (returning) {
-        const label = keptDrafts.value.get(returning.id)?.label ?? returning.id
-        if (editItemId.value !== null) {
-          // The one-editor-at-a-time gate outranks the restore: opening a
-          // second editor here would be the exact two-drafts-one-Save state
-          // `isEditingElsewhere` exists to prevent. The correction stays held.
-          notices.push(draftNotice('blocked', label))
-        } else if (!isActionDisabled(returning)) {
-          // The editor announces the restore itself, once the draft is
-          // actually back over the re-read server text.
-          openEditor(returning)
-        }
-      }
     }
-
-    if (notices.length > 0) draftNotices.value = notices
   },
 )
 
@@ -307,8 +390,7 @@ watch(
     // Entering archived history closes the editor through this watcher rather
     // than through the list, so it is a second door onto the same loss: take
     // the correction the same way, and say so.
-    const kept = keepOpenDraft()
-    if (kept) draftNotices.value = [kept]
+    keepOpenDraft()
     editItemId.value = null
     editItemLabel.value = null
     boardPickItemId.value = null
@@ -447,36 +529,41 @@ function isActionDisabled(item: CaptureItemSummary): boolean {
     isEditingElsewhere(item)
 }
 
-/**
- * The single way the editor opens, whether the user asked or a held correction
- * came back with its row — so both routes record the row's name for the
- * receipt and both cancel a board pick in progress.
- */
-function openEditor(item: CaptureItemSummary) {
+function onEdit(item: CaptureItemSummary) {
+  if (isActionDisabled(item)) return
   // Opening the editor cancels a board pick in progress: they compete for the
   // same row and the same decision, and leaving both open would let a stale
   // pick confirm against text that is being rewritten.
   cancelBoardPick()
   editItemId.value = item.id
+  // Recorded here because the line about this correction is written at the
+  // moment the row LEAVES the list, when the summary carrying the excerpt is
+  // no longer in `items`.
   editItemLabel.value = captureLabel(item)
 }
 
-function onEdit(item: CaptureItemSummary) {
-  if (isActionDisabled(item)) return
-  openEditor(item)
-}
-
 /**
- * An EXPLICIT end to the edit — Cancel, or a Save that landed (the editor
- * emits `close` for both).
+ * The editor emitted `close` — from FOUR places with two different meanings,
+ * so the editor is asked which before anything is released.
  *
- * Either way the correction stops being unsaved text the user is owed: a saved
- * one is on the server, and a cancelled one was abandoned on purpose. Holding
- * a copy past that point would hand it back on the next return, which is the
- * opposite of what Cancel means.
+ * Cancel and a landed Save come from a loaded editor: the correction is either
+ * on the server or deliberately abandoned, and the receipts about it are spent
+ * with it. Cancel on the load-error panel and Close on the refused panel come
+ * from an editor that never showed a textarea — those buttons answer the
+ * failed read, not a correction the reader was never shown, so what is held
+ * stays held and says so.
  */
 function closeEdit() {
-  if (editItemId.value !== null) keptDrafts.value.delete(editItemId.value)
+  const itemId = editItemId.value
+  if (itemId !== null) {
+    const report = readOpenEditor()
+    if (report.state === 'ready') {
+      keptDrafts.value.delete(itemId)
+      draftReceipts.value.delete(itemId)
+    } else if (keptDrafts.value.has(itemId)) {
+      setReceipt('kept', itemId, editItemLabel.value ?? itemId)
+    }
+  }
   editItemId.value = null
   editItemLabel.value = null
 }
@@ -484,7 +571,7 @@ function closeEdit() {
 /** The editor has put a held correction back; say which one, once it is true. */
 function onDraftRestored(itemId: string) {
   const label = keptDrafts.value.get(itemId)?.label ?? editItemLabel.value ?? itemId
-  draftNotices.value = [draftNotice('restored', label)]
+  setReceipt('restored', itemId, label)
 }
 
 function hasBoard(item: CaptureItemSummary): boolean {
@@ -754,28 +841,43 @@ function recordedOr(value: string | null | undefined): string {
     </header>
 
     <!--
-      What became of an unsaved correction whose capture left the list (#1999
+      Where an unsaved correction stands once its capture left the list (#1999
       item 3). It sits above the list rather than on a row because the capture
-      it is about is usually not on screen when it is written, and it outlives
-      the row that produced it. `role="status"` and not `alert`: nothing has
-      gone wrong in the kept, restored and blocked cases, and even the discard
-      is a stated consequence rather than a failure.
+      it is about is often not on screen, and because it outlives the row that
+      produced it.
+
+      MOUNTED AND SILENT until it has something to say (#2593/#2630): a live
+      region inserted at the same moment its text appears is announced
+      unreliably, so the region is always here and only its lines come and go.
+      It is never `display: none` either, which would take it back out of the
+      accessibility tree and undo exactly that.
+
+      `role="status"` and not `alert`: five of the six lines are about a
+      correction that is safe, and the sixth is a stated consequence rather
+      than a failure. `aria-atomic="false"` because the region carries one
+      independent line per capture — a change about one correction must not
+      re-read the others.
     -->
     <div
-      v-if="draftNotices.length > 0"
       class="paper-triage__draft-notices"
+      :class="{ 'paper-triage__draft-notices--speaking': draftNoticeLines.length > 0 }"
       role="status"
+      aria-live="polite"
+      aria-atomic="false"
+      tabindex="-1"
       data-testid="capture-draft-notices"
     >
       <p
-        v-for="notice in draftNotices"
-        :key="notice.key"
+        v-for="line in draftNoticeLines"
+        :key="line.captureId"
         class="paper-triage__draft-notice"
-        :data-notice="notice.kind"
+        :data-notice="line.kind"
+        :data-capture-id="line.captureId"
       >
-        {{ t(`inbox.triage.draft.${notice.kind}`, { capture: notice.capture, status: notice.status }) }}
+        {{ t(`inbox.triage.draft.${line.kind}`, { capture: line.capture, status: line.status }) }}
       </p>
       <button
+        v-if="hasDismissableNotice"
         type="button"
         class="paper-triage__retry paper-triage__draft-dismiss"
         data-action="dismiss-draft-notice"
@@ -1095,10 +1197,12 @@ function recordedOr(value: string | null | undefined): string {
           -->
           <!--
             `restored-draft` is the correction this table held while the
-            capture was off the list (#1999). The editor re-reads the server
-            text either way and lays the draft over it, so a restore is never
-            a stale write: what Save sends is measured against the capture as
-            it stands now.
+            capture was off the list (#1999). It carries only the fields the
+            reader actually changed, and the editor lays those over the values
+            it re-reads on mount — so an untouched due date or label is the
+            server's current one, not the one the old load happened to see.
+            Save is still last-write-wins, exactly as it is from an editor
+            opened fresh: the hold buys no extra staleness, and claims none.
           -->
           <PaperTriageRowEdit
             ref="openEditorRefs"
@@ -1170,11 +1274,19 @@ function recordedOr(value: string | null | undefined): string {
   cursor: pointer;
 }
 /*
- * The draft-fate receipt (#1999 item 3). Set in the note palette rather than
- * the failure one: three of its four sentences are about a correction that was
- * KEPT, and the fourth is a stated consequence, not an error.
+ * The draft-fate region (#1999 item 3). Set in the note palette rather than
+ * the failure one: five of its six sentences are about a correction that is
+ * safe, and the sixth is a stated consequence, not an error.
+ *
+ * The region is always mounted, so the bare class must occupy nothing — no
+ * border, no padding, no margin. `display: none` is deliberately NOT used: it
+ * would remove the live region from the accessibility tree, which is the one
+ * thing being always-mounted exists to avoid.
  */
-.paper-triage__draft-notices {
+.paper-triage__draft-notices:focus {
+  outline: none;
+}
+.paper-triage__draft-notices--speaking {
   margin-bottom: 12px;
   padding: 10px 12px;
   border: 1px solid var(--line-soft);