diff --git a/src/main/codex-accounts/fs-utils-remove-retry.test.ts b/src/main/codex-accounts/fs-utils-remove-retry.test.ts
new file mode 100644
index 00000000000..aee362f9d10
--- /dev/null
+++ b/src/main/codex-accounts/fs-utils-remove-retry.test.ts
@@ -0,0 +1,60 @@
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import type * as NodeFsPromises from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const fsPromises = vi.hoisted(() => ({ rm: vi.fn() }))
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof NodeFsPromises>()
+  fsPromises.rm.mockImplementation(actual.rm)
+  return { ...actual, rm: fsPromises.rm }
+})
+
+import { removeFileWithWindowsRetryAsync } from './fs-utils'
+
+const originalPlatform = process.platform
+const dirs: string[] = []
+
+function fileInTempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), 'orca-fs-remove-retry-'))
+  dirs.push(dir)
+  const file = join(dir, 'draft.json')
+  writeFileSync(file, '{}')
+  return file
+}
+
+afterEach(() => {
+  Object.defineProperty(process, 'platform', { value: originalPlatform })
+  fsPromises.rm.mockClear()
+  dirs.splice(0).forEach((dir) => rmSync(dir, { recursive: true, force: true }))
+})
+
+describe('removeFileWithWindowsRetryAsync', () => {
+  // An antivirus scan holding the file open must not fail the delete (#1507).
+  it('retries a Windows sharing violation', async () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' })
+    const file = fileInTempDir()
+    fsPromises.rm.mockRejectedValueOnce(Object.assign(new Error('busy'), { code: 'EBUSY' }))
+
+    await removeFileWithWindowsRetryAsync(file)
+
+    expect(fsPromises.rm).toHaveBeenCalledTimes(2)
+    expect(existsSync(file)).toBe(false)
+  })
+
+  it('treats a missing file as deleted', async () => {
+    const file = fileInTempDir()
+    await removeFileWithWindowsRetryAsync(file)
+    await expect(removeFileWithWindowsRetryAsync(file)).resolves.toBeUndefined()
+  })
+
+  it('does not retry off Windows', async () => {
+    Object.defineProperty(process, 'platform', { value: 'darwin' })
+    fsPromises.rm.mockRejectedValueOnce(Object.assign(new Error('busy'), { code: 'EBUSY' }))
+
+    await expect(removeFileWithWindowsRetryAsync(fileInTempDir())).rejects.toThrow('busy')
+    expect(fsPromises.rm).toHaveBeenCalledOnce()
+  })
+})
diff --git a/src/main/codex-accounts/fs-utils.ts b/src/main/codex-accounts/fs-utils.ts
index 295dfac9b66..3d599a0671d 100644
--- a/src/main/codex-accounts/fs-utils.ts
+++ b/src/main/codex-accounts/fs-utils.ts
@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto'
 import { copyFileSync, existsSync, linkSync, renameSync, rmSync, writeFileSync } from 'node:fs'
-import { rename } from 'node:fs/promises'
+import { rename, rm } from 'node:fs/promises'
 import { dirname } from 'node:path'
 import { setTimeout } from 'node:timers/promises'
 import { grantDirAcl, isPermissionError } from '../win32-utils'
@@ -224,6 +224,21 @@ export async function renameFileWithWindowsRetryAsync(
   }
 }
 
+/** Deletes `target`, treating a missing file as deleted; retries like the rename above (#1507). */
+export async function removeFileWithWindowsRetryAsync(target: string): Promise<void> {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      await rm(target, { force: true })
+      return
+    } catch (error) {
+      if (!shouldRetryFileOperation(error, attempt)) {
+        throw error
+      }
+      await setTimeout(attempt * 50)
+    }
+  }
+}
+
 export function copyFileWithWindowsRetry(source: string, target: string): void {
   runFileOperationWithWindowsRetry(() => copyFileSync(source, target))
 }
diff --git a/src/main/durable-file-write-process.test.ts b/src/main/durable-file-write-process.test.ts
new file mode 100644
index 00000000000..ca8bd5ea840
--- /dev/null
+++ b/src/main/durable-file-write-process.test.ts
@@ -0,0 +1,53 @@
+import { mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs'
+import type * as NodeFsPromises from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const fsPromises = vi.hoisted(() => ({ rm: vi.fn(), rename: vi.fn() }))
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof NodeFsPromises>()
+  fsPromises.rm.mockImplementation(actual.rm)
+  fsPromises.rename.mockImplementation(actual.rename)
+  return { ...actual, rm: fsPromises.rm, rename: fsPromises.rename }
+})
+
+import { durableWriteTempPath, writeFileProcessDurable } from './durable-file-write'
+
+const dirs: string[] = []
+
+function tempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), 'orca-process-durable-'))
+  dirs.push(dir)
+  return dir
+}
+
+afterEach(() => {
+  fsPromises.rm.mockClear()
+  fsPromises.rename.mockClear()
+  dirs.splice(0).forEach((dir) => rmSync(dir, { recursive: true, force: true }))
+})
+
+describe('writeFileProcessDurable', () => {
+  // The temp file is gone once renamed; removing it again is a wasted file-system call.
+  it('renames the temp file into place without removing it afterwards', async () => {
+    const file = join(tempDir(), 'draft.json')
+
+    await writeFileProcessDurable(durableWriteTempPath(file), file, '{"a":1}')
+
+    expect(readFileSync(file, 'utf8')).toBe('{"a":1}')
+    expect(fsPromises.rm).not.toHaveBeenCalled()
+  })
+
+  it('removes the temp file when the rename fails', async () => {
+    const dir = tempDir()
+    const file = join(dir, 'draft.json')
+    fsPromises.rename.mockRejectedValueOnce(Object.assign(new Error('denied'), { code: 'EACCES' }))
+
+    await expect(
+      writeFileProcessDurable(durableWriteTempPath(file), file, '{"a":1}')
+    ).rejects.toThrow('denied')
+    expect(readdirSync(dir)).toEqual([])
+  })
+})
diff --git a/src/main/durable-file-write.ts b/src/main/durable-file-write.ts
index 05e849327b7..96c04c43f7d 100644
--- a/src/main/durable-file-write.ts
+++ b/src/main/durable-file-write.ts
@@ -4,7 +4,7 @@
 // hour's loss; fsync stops it from happening.
 
 import { closeSync, fsyncSync, openSync, rmSync, writeFileSync } from 'node:fs'
-import { copyFile, open, readdir, rm, stat } from 'node:fs/promises'
+import { copyFile, open, readdir, rm, stat, writeFile } from 'node:fs/promises'
 import { basename, dirname, join } from 'node:path'
 import {
   publishFileWithoutOverwrite,
@@ -165,6 +165,26 @@ export async function writeFileDurableIfCurrent(
   }
 }
 
+/**
+ * Write to a temp file and rename it over `finalPath`, with no fsync. Survives the process being
+ * killed once it returns, since the rename sits in the page cache; a power loss can still revert it.
+ */
+export async function writeFileProcessDurable(
+  tmpPath: string,
+  finalPath: string,
+  payload: string
+): Promise<void> {
+  let renamed = false
+  try {
+    await writeFile(tmpPath, payload, { mode: 0o600 })
+    renamed = await renameFileWithWindowsRetryAsync(tmpPath, finalPath)
+  } finally {
+    if (!renamed) {
+      await rm(tmpPath, { force: true }).catch(() => {})
+    }
+  }
+}
+
 /** Temp path for a durable write. Shared shape so `removeStaleDurableWriteTempFiles` can reclaim orphans. */
 export function durableWriteTempPath(finalPath: string): string {
   return `${finalPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
diff --git a/src/main/ipc/filesystem-auth.ts b/src/main/ipc/filesystem-auth.ts
index 620baa9b595..2567971b815 100644
--- a/src/main/ipc/filesystem-auth.ts
+++ b/src/main/ipc/filesystem-auth.ts
@@ -3,6 +3,7 @@ import { realpathSync } from 'node:fs'
 import { realpath } from 'node:fs/promises'
 import type { Store } from '../persistence'
 import { getAllowedRoots } from './filesystem-allowed-roots'
+import { getNativeChatAttachmentAllowedRoots } from '../window/native-chat-attachment-store'
 import { isDescendantOrEqual, isENOENT, normalizeExistingPath } from './filesystem-path-containment'
 import {
   ensureAuthorizedRootsCache,
@@ -54,7 +55,12 @@ type AllowedRootsSnapshot = { get: () => readonly string[] }
 
 function createAllowedRootsSnapshot(store: Store): AllowedRootsSnapshot {
   let roots: readonly string[] | undefined
-  return { get: () => (roots ??= getAllowedRoots(store)) }
+  return { get: () => (roots ??= getAuthorizedRoots(store)) }
+}
+
+/** Workspace roots, plus Orca's own storage for chat draft images so a relaunch can read them. */
+function getAuthorizedRoots(store: Store): string[] {
+  return [...getAllowedRoots(store), ...getNativeChatAttachmentAllowedRoots()]
 }
 
 export function isPathAllowed(
@@ -71,7 +77,7 @@ export function isPathAllowed(
       return true
     }
   }
-  return (allowedRoots?.get() ?? getAllowedRoots(store)).some((root) =>
+  return (allowedRoots?.get() ?? getAuthorizedRoots(store)).some((root) =>
     isDescendantOrEqual(resolvedTarget, root)
   )
 }
@@ -223,7 +229,7 @@ async function isPathAllowedByCanonicalAllowedRoot(
   if (!sourcePath) {
     return false
   }
-  for (const root of allowedRoots?.get() ?? getAllowedRoots(store)) {
+  for (const root of allowedRoots?.get() ?? getAuthorizedRoots(store)) {
     const resolvedRoot = resolve(root)
     if (!isDescendantOrEqual(sourcePath, resolvedRoot)) {
       continue
diff --git a/src/main/ipc/native-chat-drafts.test.ts b/src/main/ipc/native-chat-drafts.test.ts
new file mode 100644
index 00000000000..29d08949166
--- /dev/null
+++ b/src/main/ipc/native-chat-drafts.test.ts
@@ -0,0 +1,129 @@
+import { mkdtemp, readdir, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type * as SidecarSnapshotFile from '../sidecar-snapshot-file'
+
+const { handlers, listeners, ipcMainMock, isTrustedUIRendererMock } = vi.hoisted(() => {
+  const handlerMap = new Map<string, (...args: unknown[]) => unknown>()
+  const listenerMap = new Map<string, (...args: unknown[]) => void>()
+  return {
+    handlers: handlerMap,
+    listeners: listenerMap,
+    ipcMainMock: {
+      removeHandler: vi.fn(),
+      removeAllListeners: vi.fn(),
+      handle: (channel: string, fn: (...args: unknown[]) => unknown) => handlerMap.set(channel, fn),
+      on: (channel: string, fn: (...args: unknown[]) => void) => listenerMap.set(channel, fn)
+    },
+    isTrustedUIRendererMock: vi.fn(() => true)
+  }
+})
+
+const sidecar = vi.hoisted(() => ({ removeSidecarSnapshot: vi.fn() }))
+
+vi.mock('../sidecar-snapshot-file', async (importOriginal) => {
+  const actual = await importOriginal<typeof SidecarSnapshotFile>()
+  sidecar.removeSidecarSnapshot.mockImplementation(actual.removeSidecarSnapshot)
+  return { ...actual, removeSidecarSnapshot: sidecar.removeSidecarSnapshot }
+})
+vi.mock('electron', () => ({ ipcMain: ipcMainMock }))
+vi.mock('./ui', () => ({ isTrustedUIRenderer: isTrustedUIRendererMock }))
+
+import { drainNativeChatDrafts, registerNativeChatDraftHandlers } from './native-chat-drafts'
+
+const trusted = { sender: { id: 1 } }
+const draft = { text: 'hello', attachments: [] }
+let tempRoot = ''
+let root = ''
+
+function invoke(channel: string, event: unknown, args?: unknown): unknown {
+  const handler = handlers.get(channel)
+  if (!handler) {
+    throw new Error(`no handler for ${channel}`)
+  }
+  return handler(event, args)
+}
+
+function loadSync(event: { sender: { id: number } }): unknown {
+  const reply: { sender: { id: number }; returnValue?: unknown } = { ...event }
+  listeners.get('nativeChat:drafts:loadSync')?.(reply)
+  return reply.returnValue
+}
+
+beforeEach(async () => {
+  tempRoot = await mkdtemp(join(tmpdir(), 'orca-native-chat-draft-ipc-'))
+  root = join(tempRoot, 'native-chat-drafts')
+  isTrustedUIRendererMock.mockReturnValue(true)
+  registerNativeChatDraftHandlers(root)
+})
+
+afterEach(async () => {
+  await drainNativeChatDrafts()
+  await rm(tempRoot, { recursive: true, force: true })
+})
+
+describe('native chat draft IPC', () => {
+  it('saves, loads and clears a draft for the app window', async () => {
+    await expect(
+      invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft })
+    ).resolves.toBe('persisted')
+    await expect(invoke('nativeChat:drafts:load', trusted)).resolves.toEqual([
+      { scopeKey: 'session:s1', draft }
+    ])
+    expect(loadSync(trusted)).toEqual([{ scopeKey: 'session:s1', draft }])
+
+    await invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft: null })
+    expect(await readdir(root)).toEqual([])
+  })
+
+  it('refuses every other renderer', async () => {
+    await invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft })
+    isTrustedUIRendererMock.mockReturnValue(false)
+    const other = { sender: { id: 2 } }
+
+    expect(await invoke('nativeChat:drafts:write', other, { scopeKey: 'session:s2', draft })).toBe(
+      'failed'
+    )
+    expect(
+      await invoke('nativeChat:drafts:write', other, { scopeKey: 'session:s1', draft: null })
+    ).toBe('failed')
+    expect(await invoke('nativeChat:drafts:load', other)).toEqual([])
+    expect(loadSync(other)).toEqual([])
+    isTrustedUIRendererMock.mockReturnValue(true)
+    expect(await invoke('nativeChat:drafts:load', trusted)).toEqual([
+      { scopeKey: 'session:s1', draft }
+    ])
+  })
+
+  it('refuses a write without a chat', async () => {
+    expect(await invoke('nativeChat:drafts:write', trusted, { draft })).toBe('failed')
+    expect(await invoke('nativeChat:drafts:write', trusted, null)).toBe('failed')
+  })
+
+  // macOS keeps Orca running with no window; reopening one registers the handlers again.
+  it('keeps the same store when the window is reopened, so a failed clear is still owed', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    await invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft })
+    sidecar.removeSidecarSnapshot.mockRejectedValueOnce(
+      Object.assign(new Error('denied'), { code: 'EACCES' })
+    )
+    expect(
+      await invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft: null })
+    ).toBe('failed')
+
+    registerNativeChatDraftHandlers(root)
+
+    expect(await invoke('nativeChat:drafts:load', trusted)).toEqual([])
+    await drainNativeChatDrafts()
+    expect(await readdir(root)).toEqual([])
+  })
+
+  it('lets a draft written just before quitting land before the app exits', async () => {
+    void invoke('nativeChat:drafts:write', trusted, { scopeKey: 'session:s1', draft })
+
+    await drainNativeChatDrafts()
+
+    expect((await readdir(root)).filter((name) => name.endsWith('.json'))).toHaveLength(1)
+  })
+})
diff --git a/src/main/ipc/native-chat-drafts.ts b/src/main/ipc/native-chat-drafts.ts
new file mode 100644
index 00000000000..9a7e71af2c6
--- /dev/null
+++ b/src/main/ipc/native-chat-drafts.ts
@@ -0,0 +1,51 @@
+import { ipcMain } from 'electron'
+import {
+  parseNativeChatDraft,
+  type NativeChatDraftStoreResult,
+  type SavedNativeChatDraft
+} from '../../shared/native-chat-draft-record'
+import {
+  createNativeChatDraftStore,
+  type NativeChatDraftStore
+} from '../native-chat/native-chat-draft-store'
+import { isTrustedUIRenderer } from './ui'
+
+// Why one per root: macOS keeps the app alive with no window, and a reopened window must find the
+// same store, with its failed writes still owed, rather than a second one reading the files anew.
+const stores = new Map<string, NativeChatDraftStore>()
+
+/** Drafts are the app window's own; no other renderer may read or write them. */
+export function registerNativeChatDraftHandlers(root: string): void {
+  const drafts = stores.get(root) ?? createNativeChatDraftStore(root)
+  stores.set(root, drafts)
+  ipcMain.removeHandler('nativeChat:drafts:load')
+  ipcMain.removeHandler('nativeChat:drafts:write')
+  ipcMain.removeAllListeners('nativeChat:drafts:loadSync')
+  ipcMain.handle(
+    'nativeChat:drafts:load',
+    (event): Promise<SavedNativeChatDraft[]> | SavedNativeChatDraft[] =>
+      isTrustedUIRenderer(event.sender) ? drafts.load() : []
+  )
+  ipcMain.on('nativeChat:drafts:loadSync', (event) => {
+    event.returnValue = isTrustedUIRenderer(event.sender) ? drafts.loadSync() : []
+  })
+  ipcMain.handle(
+    'nativeChat:drafts:write',
+    (event, args: unknown): Promise<NativeChatDraftStoreResult> | NativeChatDraftStoreResult => {
+      if (!isTrustedUIRenderer(event.sender) || typeof args !== 'object' || args === null) {
+        return 'failed'
+      }
+      const scopeKey = 'scopeKey' in args ? args.scopeKey : undefined
+      if (typeof scopeKey !== 'string' || scopeKey === '') {
+        return 'failed'
+      }
+      // A cleared draft is null; anything unreadable is treated as cleared, never written.
+      return drafts.write(scopeKey, 'draft' in args ? parseNativeChatDraft(args.draft) : null)
+    }
+  )
+}
+
+/** Lets drafts written just before quitting land before the app exits. */
+export async function drainNativeChatDrafts(): Promise<void> {
+  await Promise.all(Array.from(stores.values(), (drafts) => drafts.drain()))
+}
diff --git a/src/main/ipc/register-core-handlers/register-core-handlers.test.ts b/src/main/ipc/register-core-handlers/register-core-handlers.test.ts
index 4e67441ea34..d878829f757 100644
--- a/src/main/ipc/register-core-handlers/register-core-handlers.test.ts
+++ b/src/main/ipc/register-core-handlers/register-core-handlers.test.ts
@@ -65,6 +65,7 @@ const {
   registerWorkspacePortHandlersMock,
   registerLocalhostWorktreeLabelHandlersMock,
   registerNativeChatHandlersMock,
+  registerNativeChatDraftHandlersMock,
   registerEmulatorFrameStreamHandlersMock,
   registerEmulatorVideoStreamHandlersMock
 } = vi.hoisted(() => ({
@@ -132,6 +133,7 @@ const {
   registerWorkspacePortHandlersMock: vi.fn(),
   registerLocalhostWorktreeLabelHandlersMock: vi.fn(),
   registerNativeChatHandlersMock: vi.fn(),
+  registerNativeChatDraftHandlersMock: vi.fn(),
   registerEmulatorFrameStreamHandlersMock: vi.fn(),
   registerEmulatorVideoStreamHandlersMock: vi.fn()
 }))
@@ -394,6 +396,10 @@ vi.mock('../native-chat', () => ({
   registerNativeChatHandlers: registerNativeChatHandlersMock
 }))
 
+vi.mock('../native-chat-drafts', () => ({
+  registerNativeChatDraftHandlers: registerNativeChatDraftHandlersMock
+}))
+
 import { agentSessionRefusalError } from '../../../shared/agent-session-wire-refusals'
 import { recordStructuredAgentSessionHostInstallRefusal } from '../../runtime/structured-agent-session-host-refusal'
 import { registerCoreHandlers } from './register-core-handlers'
@@ -586,6 +592,9 @@ describe('registerCoreHandlers', () => {
     )
     expect(aiVaultOptions.getActiveRuntimeAiVaultHostInfos()).toEqual([])
     expect(registerNativeChatHandlersMock).toHaveBeenCalled()
+    expect(registerNativeChatDraftHandlersMock).toHaveBeenCalledWith(
+      expect.stringContaining('native-chat-drafts')
+    )
     expect(registerCliHandlersMock).toHaveBeenCalled()
     expect(registerPreflightHandlersMock).toHaveBeenCalled()
     expect(registerShellHandlersMock).toHaveBeenCalledWith(store)
diff --git a/src/main/ipc/register-core-handlers/register-core-handlers.ts b/src/main/ipc/register-core-handlers/register-core-handlers.ts
index d3a647cafd7..113754b8046 100644
--- a/src/main/ipc/register-core-handlers/register-core-handlers.ts
+++ b/src/main/ipc/register-core-handlers/register-core-handlers.ts
@@ -1,4 +1,5 @@
 import { app } from 'electron'
+import { join } from 'node:path'
 import { registerAppHandlers } from '../app'
 import { registerCliHandlers } from '../cli'
 import { registerPreflightHandlers } from '../preflight'
@@ -27,6 +28,7 @@ import { registerEphemeralVmHandlers } from '../ephemeral-vm'
 import { registerAiVaultHandlers } from '../ai-vault'
 import { registerAiVaultSearchHandlers } from '../ai-vault-search'
 import { registerNativeChatHandlers } from '../native-chat'
+import { registerNativeChatDraftHandlers } from '../native-chat-drafts'
 import { registerNotificationHandlers } from '../notifications'
 import { registerNotebookHandlers } from '../notebook'
 import { registerOnboardingHandlers } from '../onboarding'
@@ -241,6 +243,7 @@ export function registerCoreHandlers(
       prepareRuntimeAiVaultSessionResume(app.getPath('userData'), environmentId, args)
   })
   registerNativeChatHandlers()
+  registerNativeChatDraftHandlers(join(app.getPath('userData'), 'native-chat-drafts'))
   registerClipboardHandlers(store)
   registerUpdaterHandlers(store)
   registerSpeechHandlers(store)
diff --git a/src/main/native-chat/native-chat-draft-send-kill.test.ts b/src/main/native-chat/native-chat-draft-send-kill.test.ts
new file mode 100644
index 00000000000..b6ea3554f99
--- /dev/null
+++ b/src/main/native-chat/native-chat-draft-send-kill.test.ts
@@ -0,0 +1,96 @@
+// The send ordering against a real kill: the composer's draft cache, saving through this main
+// store, in a child process that SIGKILLs itself while a message is out. A kill before the host has
+// the message must leave it saved (restored unsent); one after the save that follows must not.
+
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { build } from 'esbuild'
+import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest'
+import { runProcess } from '../../shared/child-process/run-process'
+import { createNativeChatDraftStore } from './native-chat-draft-store'
+
+const CACHE = resolve(
+  __dirname,
+  '../../renderer/src/components/native-chat/native-chat-draft-cache'
+)
+
+const CHILD_SOURCE = `
+import { createNativeChatDraftStore } from './native-chat-draft-store'
+import {
+  clearNativeChatDraftForSend,
+  writeNativeChatDraftCache
+} from ${JSON.stringify(CACHE)}
+const [root, mode] = process.argv.slice(2)
+const store = createNativeChatDraftStore(root)
+// The desktop bridge, minus the IPC hop.
+Object.assign(globalThis, { window: { api: { nativeChat: { drafts: store } } } })
+const KEY = 'session:s1'
+void (async () => {
+  writeNativeChatDraftCache(KEY, 'sent text', 'now')
+  await store.drain()
+  // Enter: the box empties and the message goes out; the host has not taken it yet.
+  const save = clearNativeChatDraftForSend(KEY, () => writeNativeChatDraftCache(KEY, '', 'now'))
+  if (mode === 'host-took-it') {
+    save()
+  }
+  // Every write asked of the store so far has landed before the kill.
+  await store.drain()
+  process.stdout.write('killing', () => process.kill(process.pid, 'SIGKILL'))
+})()
+`
+
+const roots: string[] = []
+let bundleDir = ''
+let childEntry = ''
+
+beforeAll(async () => {
+  bundleDir = await mkdtemp(join(tmpdir(), 'orca-native-chat-draft-send-kill-'))
+  childEntry = join(bundleDir, 'send-kill-child.cjs')
+  await build({
+    stdin: { contents: CHILD_SOURCE, resolveDir: __dirname, loader: 'ts' },
+    outfile: childEntry,
+    bundle: true,
+    platform: 'node',
+    target: 'node18',
+    format: 'cjs',
+    external: ['electron', '@tiptap/react'],
+    logLevel: 'silent'
+  })
+}, 30_000)
+
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
+})
+
+afterAll(async () => {
+  if (bundleDir) {
+    await rm(bundleDir, { recursive: true, force: true })
+  }
+})
+
+async function killedDuringSend(mode: 'before-host' | 'host-took-it') {
+  const tempRoot = await mkdtemp(join(tmpdir(), 'orca-native-chat-drafts-'))
+  roots.push(tempRoot)
+  const root = join(tempRoot, 'native-chat-drafts')
+  const child = await runProcess({
+    program: process.execPath,
+    args: [childEntry, root, mode],
+    timeoutMs: 20_000
+  })
+  expect(child.stdout).toBe('killing')
+  expect(child.signal).toBe('SIGKILL')
+  return createNativeChatDraftStore(root).load()
+}
+
+describe('a send killed partway', () => {
+  it('restores the message when the host did not have it yet', async () => {
+    expect(await killedDuringSend('before-host')).toEqual([
+      { scopeKey: 'session:s1', draft: { text: 'sent text', attachments: [] } }
+    ])
+  })
+
+  it('does not bring the message back once the host had it and the box was saved', async () => {
+    expect(await killedDuringSend('host-took-it')).toEqual([])
+  })
+})
diff --git a/src/main/native-chat/native-chat-draft-store.bench.test.ts b/src/main/native-chat/native-chat-draft-store.bench.test.ts
new file mode 100644
index 00000000000..8fcc5df71d5
--- /dev/null
+++ b/src/main/native-chat/native-chat-draft-store.bench.test.ts
@@ -0,0 +1,88 @@
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { performance } from 'node:perf_hooks'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { createNativeChatDraftStore, type NativeChatDraftStore } from './native-chat-draft-store'
+
+// How long a draft write takes in the main process (the IPC hop is not here): the save after a
+// send, and the bounded wait a queued message's take-back does before deleting the host's copy.
+const ITERATIONS = 1000
+const BUDGET_P50_MS = 2
+const BUDGET_P99_MS = 20
+const describeBench = process.env.ORCA_NATIVE_CHAT_DRAFT_BENCH === '1' ? describe : describe.skip
+
+function percentile(samples: number[], fraction: number): number {
+  const sorted = [...samples].sort((a, b) => a - b)
+  return sorted[Math.ceil(sorted.length * fraction) - 1]!
+}
+
+const typed = (index: number) => ({
+  text: `a message being typed ${index} `.repeat(8),
+  attachments: []
+})
+
+async function timeClears(
+  store: NativeChatDraftStore,
+  before: (scopeKey: string, index: number) => Promise<unknown>
+): Promise<{ p50: number; p99: number }> {
+  const samples: number[] = []
+  for (let index = 0; index < ITERATIONS; index += 1) {
+    const scopeKey = `session:bench-${index % 16}`
+    await before(scopeKey, index)
+    const startedAt = performance.now()
+    await store.write(scopeKey, null)
+    samples.push(performance.now() - startedAt)
+  }
+  return { p50: percentile(samples, 0.5), p99: percentile(samples, 0.99) }
+}
+
+describeBench('native chat draft store latency', () => {
+  let root = ''
+  let store: NativeChatDraftStore
+
+  beforeAll(async () => {
+    root = await mkdtemp(join(tmpdir(), 'orca-native-chat-draft-bench-'))
+    store = createNativeChatDraftStore(join(root, 'drafts'))
+    await store.load()
+  })
+
+  afterAll(async () => {
+    await rm(root, { recursive: true, force: true })
+  })
+
+  it.each([
+    ['clear alone', async () => {}],
+    [
+      'clear after a typing write',
+      (scopeKey: string, index: number) => store.write(scopeKey, typed(index))
+    ],
+    [
+      'clear with a typing write in flight',
+      async (scopeKey: string, index: number) => void store.write(scopeKey, typed(index))
+    ]
+  ] as const)('%s', async (name, before) => {
+    const { p50, p99 } = await timeClears(store, before)
+    console.log(
+      `[native-chat-draft-bench] ${name}: p50=${p50.toFixed(3)}ms p99=${p99.toFixed(3)}ms`
+    )
+    expect(p50).toBeLessThanOrEqual(BUDGET_P50_MS)
+    expect(p99).toBeLessThanOrEqual(BUDGET_P99_MS)
+  })
+
+  it('put-back rewrite', async () => {
+    const samples: number[] = []
+    for (let index = 0; index < ITERATIONS; index += 1) {
+      const startedAt = performance.now()
+      await store.write(`session:bench-${index % 16}`, typed(index))
+      samples.push(performance.now() - startedAt)
+    }
+    const p50 = percentile(samples, 0.5)
+    const p99 = percentile(samples, 0.99)
+    console.log(
+      `[native-chat-draft-bench] put-back rewrite: p50=${p50.toFixed(3)}ms p99=${p99.toFixed(3)}ms`
+    )
+    expect(p50).toBeLessThanOrEqual(BUDGET_P50_MS)
+    expect(p99).toBeLessThanOrEqual(BUDGET_P99_MS)
+  })
+})
diff --git a/src/main/native-chat/native-chat-draft-store.failed-write.test.ts b/src/main/native-chat/native-chat-draft-store.failed-write.test.ts
new file mode 100644
index 00000000000..30e2efaa4c5
--- /dev/null
+++ b/src/main/native-chat/native-chat-draft-store.failed-write.test.ts
@@ -0,0 +1,135 @@
+import { mkdtemp, readdir, rm } from 'node:fs/promises'
+import type * as NodeFsPromises from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type * as SidecarSnapshotFile from '../sidecar-snapshot-file'
+
+const mocks = vi.hoisted(() => ({
+  removeSidecarSnapshot: vi.fn(),
+  writeSidecarSnapshot: vi.fn(),
+  mkdir: vi.fn()
+}))
+
+vi.mock('../sidecar-snapshot-file', async (importOriginal) => {
+  const actual = await importOriginal<typeof SidecarSnapshotFile>()
+  mocks.removeSidecarSnapshot.mockImplementation(actual.removeSidecarSnapshot)
+  mocks.writeSidecarSnapshot.mockImplementation(actual.writeSidecarSnapshot)
+  return {
+    ...actual,
+    removeSidecarSnapshot: mocks.removeSidecarSnapshot,
+    writeSidecarSnapshot: mocks.writeSidecarSnapshot
+  }
+})
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof NodeFsPromises>()
+  mocks.mkdir.mockImplementation(actual.mkdir)
+  return { ...actual, mkdir: mocks.mkdir }
+})
+
+import { createNativeChatDraftStore } from './native-chat-draft-store'
+
+const roots: string[] = []
+const draft = (text: string) => ({ text, attachments: [] })
+const busy = () => Object.assign(new Error('busy'), { code: 'EBUSY' })
+
+async function freshRoot(): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), 'orca-native-chat-drafts-failed-'))
+  roots.push(root)
+  return join(root, 'native-chat-drafts')
+}
+
+async function sentDraftOnDisk() {
+  const root = await freshRoot()
+  const store = createNativeChatDraftStore(root)
+  await store.load()
+  await store.write('session:s1', draft('sent text'))
+  return { root, store }
+}
+
+beforeEach(() => {
+  vi.spyOn(console, 'warn').mockImplementation(() => {})
+})
+
+afterEach(async () => {
+  vi.clearAllMocks()
+  vi.restoreAllMocks()
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
+})
+
+// A clear whose delete failed must not leave the sent text to come back, in this run or the next.
+describe('a draft write that failed', () => {
+  it('is not served to a reloaded window, and is retried when Orca quits', async () => {
+    const { root, store } = await sentDraftOnDisk()
+    mocks.removeSidecarSnapshot.mockRejectedValueOnce(busy())
+
+    expect(await store.write('session:s1', null)).toBe('failed')
+    expect(await store.load()).toEqual([])
+
+    await store.drain()
+    expect(await readdir(root)).toEqual([])
+    expect(await createNativeChatDraftStore(root).load()).toEqual([])
+  })
+
+  it("is superseded by the chat's next write", async () => {
+    const { root, store } = await sentDraftOnDisk()
+    mocks.removeSidecarSnapshot.mockRejectedValueOnce(busy())
+    await store.write('session:s1', null)
+
+    expect(await store.write('session:s1', draft('typed again'))).toBe('persisted')
+    await store.drain()
+
+    expect(mocks.removeSidecarSnapshot).toHaveBeenCalledOnce()
+    expect(await createNativeChatDraftStore(root).load()).toEqual([
+      { scopeKey: 'session:s1', draft: draft('typed again') }
+    ])
+  })
+
+  it('is dropped, and logged, when the retry at quit fails too', async () => {
+    const { store } = await sentDraftOnDisk()
+    mocks.removeSidecarSnapshot.mockRejectedValueOnce(busy()).mockRejectedValueOnce(busy())
+    await store.write('session:s1', null)
+
+    await store.drain()
+    await store.drain()
+
+    expect(mocks.removeSidecarSnapshot).toHaveBeenCalledTimes(2)
+    expect(console.warn).toHaveBeenCalledWith(
+      expect.stringContaining('dropped a draft write'),
+      'EBUSY'
+    )
+  })
+
+  it('never outlives a newer write asked for before it failed', async () => {
+    const { root, store } = await sentDraftOnDisk()
+    mocks.removeSidecarSnapshot.mockRejectedValueOnce(busy())
+    const clear = store.write('session:s1', null)
+    const next = store.write('session:s1', draft('newer'))
+
+    expect(await clear).toBe('failed')
+    expect(await next).toBe('persisted')
+    await store.drain()
+
+    expect(mocks.removeSidecarSnapshot).toHaveBeenCalledOnce()
+    expect(await createNativeChatDraftStore(root).load()).toEqual([
+      { scopeKey: 'session:s1', draft: draft('newer') }
+    ])
+  })
+})
+
+describe('the drafts folder', () => {
+  it('is created once, and again after a write failed', async () => {
+    const root = await freshRoot()
+    const store = createNativeChatDraftStore(root)
+    await store.write('session:s1', draft('a'))
+    await store.write('session:s1', draft('ab'))
+    await store.write('session:s2', draft('b'))
+    expect(mocks.mkdir).toHaveBeenCalledOnce()
+
+    mocks.writeSidecarSnapshot.mockRejectedValueOnce(busy())
+    expect(await store.write('session:s1', draft('abc'))).toBe('failed')
+    await store.write('session:s1', draft('abcd'))
+    expect(mocks.mkdir).toHaveBeenCalledTimes(2)
+  })
+})
diff --git a/src/main/native-chat/native-chat-draft-store.test.ts b/src/main/native-chat/native-chat-draft-store.test.ts
new file mode 100644
index 00000000000..2a95ad92af4
--- /dev/null
+++ b/src/main/native-chat/native-chat-draft-store.test.ts
@@ -0,0 +1,283 @@
+import { createHash } from 'node:crypto'
+import { mkdir, mkdtemp, readdir, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { build } from 'esbuild'
+import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest'
+import { runProcess } from '../../shared/child-process/run-process'
+import { withSidecarSnapshotQueue } from '../sidecar-snapshot-file'
+import { createNativeChatDraftStore } from './native-chat-draft-store'
+
+const roots: string[] = []
+let bundleDir = ''
+let childEntry = ''
+
+async function freshRoot(): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), 'orca-native-chat-drafts-'))
+  roots.push(root)
+  return join(root, 'native-chat-drafts')
+}
+
+const draft = (text: string) => ({ text, attachments: [] })
+const fileOf = (scopeKey: string) => `${createHash('sha256').update(scopeKey).digest('hex')}.json`
+
+// A renderer that sends, then the app is killed: the clear it was told had landed must hold.
+const CHILD_SOURCE = `
+import { createNativeChatDraftStore } from './native-chat-draft-store'
+const [root, mode] = process.argv.slice(2)
+const store = createNativeChatDraftStore(root)
+void (async () => {
+  await store.write('session:s1', { text: 'hello', attachments: [] })
+  if (mode === 'typing-in-flight') {
+    void store.write('session:s1', { text: 'hello world', attachments: [] })
+  }
+  const result = await store.write('session:s1', null)
+  if (mode === 'typing-in-flight') {
+    await store.drain()
+  }
+  process.stdout.write(result, () => process.kill(process.pid, 'SIGKILL'))
+})()
+`
+
+beforeAll(async () => {
+  bundleDir = await mkdtemp(join(tmpdir(), 'orca-native-chat-draft-child-'))
+  childEntry = join(bundleDir, 'draft-child.cjs')
+  await build({
+    stdin: { contents: CHILD_SOURCE, resolveDir: __dirname, loader: 'ts' },
+    outfile: childEntry,
+    bundle: true,
+    platform: 'node',
+    target: 'node18',
+    format: 'cjs',
+    external: ['electron'],
+    logLevel: 'silent'
+  })
+}, 30_000)
+
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
+})
+
+afterAll(async () => {
+  if (bundleDir) {
+    await rm(bundleDir, { recursive: true, force: true })
+  }
+})
+
+describe('a clear confirmed before the app is killed', () => {
+  it.each(['clear', 'typing-in-flight'])('stays cleared (%s)', async (mode) => {
+    const root = await freshRoot()
+
+    const child = await runProcess({
+      program: process.execPath,
+      args: [childEntry, root, mode],
+      timeoutMs: 20_000
+    })
+
+    expect(child.stdout).toBe('persisted')
+    expect(child.signal).toBe('SIGKILL')
+    expect(await createNativeChatDraftStore(root).load()).toEqual([])
+  })
+})
+
+describe('the native chat draft store', () => {
+  it('loads what an earlier run saved, oldest first', async () => {
+    const root = await freshRoot()
+    const first = createNativeChatDraftStore(root)
+    await first.write('pane:tab-1:leaf-1', draft('older'))
+    await new Promise((resolve) => setTimeout(resolve, 5))
+    await first.write('session:s1', {
+      text: 'newer',
+      attachments: [{ id: 'a1', path: '/tmp/a.png', location: 'local' }],
+      tuiInputSeed: { agent: 'claude', text: 'seed', createdAt: 1 }
+    })
+
+    const next = createNativeChatDraftStore(root)
+
+    expect(await next.load()).toEqual([
+      { scopeKey: 'pane:tab-1:leaf-1', draft: draft('older') },
+      {
+        scopeKey: 'session:s1',
+        draft: {
+          text: 'newer',
+          attachments: [{ id: 'a1', path: '/tmp/a.png', location: 'local' }],
+          tuiInputSeed: { agent: 'claude', text: 'seed', createdAt: 1 }
+        }
+      }
+    ])
+    expect(next.loadSync()).toEqual(await next.load())
+  })
+
+  it('keeps the ids of outbox entries a draft took in, for a later reader', async () => {
+    const root = await freshRoot()
+    await createNativeChatDraftStore(root).write('session:s1', {
+      ...draft('back'),
+      importedOutboxEntryIds: ['m1']
+    })
+
+    expect(await createNativeChatDraftStore(root).load()).toEqual([
+      { scopeKey: 'session:s1', draft: { ...draft('back'), importedOutboxEntryIds: ['m1'] } }
+    ])
+  })
+
+  it('keeps the sends a draft still holds for their host', async () => {
+    const root = await freshRoot()
+    const heldSends = [{ clientMessageId: 'm1', text: 'sent once', attachments: [], sentAt: 5 }]
+    await createNativeChatDraftStore(root).write('session:s1', { ...draft(''), heldSends })
+
+    expect(await createNativeChatDraftStore(root).load()).toEqual([
+      { scopeKey: 'session:s1', draft: { ...draft(''), heldSends } }
+    ])
+  })
+
+  it('applies writes for one chat in the order they were asked for', async () => {
+    const root = await freshRoot()
+    const store = createNativeChatDraftStore(root)
+    const writes = [
+      store.write('session:s1', draft('h')),
+      store.write('session:s1', draft('hello')),
+      store.write('session:s1', null),
+      store.write('session:s1', draft('next'))
+    ]
+
+    expect(await Promise.all(writes)).toEqual(['persisted', 'persisted', 'persisted', 'persisted'])
+    expect(await createNativeChatDraftStore(root).load()).toEqual([
+      { scopeKey: 'session:s1', draft: draft('next') }
+    ])
+  })
+
+  it('deletes the file for a cleared draft', async () => {
+    const root = await freshRoot()
+    const store = createNativeChatDraftStore(root)
+    await store.write('session:s1', draft('hello'))
+    await store.write('session:s1', draft(''))
+
+    expect(await readdir(root)).toEqual([])
+  })
+
+  it('drops unreadable files and keeps a write made while loading', async () => {
+    const root = await freshRoot()
+    await createNativeChatDraftStore(root).write('session:s1', draft('old'))
+    await writeFile(join(root, 'broken.json'), '{not json')
+
+    const store = createNativeChatDraftStore(root)
+    const written = store.write('session:s1', draft('new'))
+
+    expect(await store.load()).toEqual([{ scopeKey: 'session:s1', draft: draft('new') }])
+    await written
+    expect((await readdir(root)).filter((name) => name === 'broken.json')).toEqual([])
+  })
+
+  it('sweeps temp files a killed run left mid-write', async () => {
+    const root = await freshRoot()
+    await createNativeChatDraftStore(root).write('session:s1', draft('hello'))
+    const [saved] = await readdir(root)
+    await writeFile(join(root, `${saved}.99999.1.ab.tmp`), '{"partial')
+
+    await createNativeChatDraftStore(root).load()
+
+    expect(await readdir(root)).toEqual([saved])
+  })
+
+  // A downgrade, or a file that can't be read right now, must not cost the user a draft.
+  it("keeps a newer build's drafts and files it could not read", async () => {
+    const root = await freshRoot()
+    const store = createNativeChatDraftStore(root)
+    await store.write('session:s1', draft('mine'))
+    const newer = { v: 2, scopeKey: 'session:s2', savedAt: 1, text: 'from a newer build' }
+    await writeFile(join(root, fileOf('session:s2')), JSON.stringify(newer))
+    // A directory where a file should be: reading it fails with something other than ENOENT.
+    await mkdir(join(root, fileOf('session:s3')))
+    await writeFile(join(root, fileOf('session:s4')), JSON.stringify({ v: 1, scopeKey: 7 }))
+
+    expect(await createNativeChatDraftStore(root).load()).toEqual([
+      { scopeKey: 'session:s1', draft: draft('mine') }
+    ])
+    expect((await readdir(root)).sort()).toEqual(
+      [fileOf('session:s1'), fileOf('session:s2'), fileOf('session:s3')].sort()
+    )
+  })
+
+  it('removes JSON files that carry no newer version', async () => {
+    const root = await freshRoot()
+    await createNativeChatDraftStore(root).write('session:s1', draft('mine'))
+    for (const [key, body] of [
+      ['session:empty', '{}'],
+      ['session:array', '[]'],
+      ['session:string', '"x"'],
+      ['session:older', JSON.stringify({ v: 0, scopeKey: 'session:older', text: 'old' })]
+    ]) {
+      await writeFile(join(root, fileOf(key)), body)
+    }
+
+    await createNativeChatDraftStore(root).load()
+
+    expect(await readdir(root)).toEqual([fileOf('session:s1')])
+  })
+
+  // Deletions at load share the chat's queue, so a write made meanwhile always survives them.
+  it('never deletes, at load, a draft written while loading', async () => {
+    const root = await freshRoot()
+    const seed = createNativeChatDraftStore(root)
+    for (let index = 0; index < 130; index += 1) {
+      await seed.write(`session:${index}`, draft(`draft-${index}`))
+      if (index < 2) {
+        await new Promise((resolve) => setTimeout(resolve, 5))
+      }
+    }
+    await writeFile(join(root, fileOf('session:garbage')), '{not json')
+
+    // Hold both chats' queues so load reads the old files, then the writes land, then load decides.
+    let release = () => {}
+    const held = new Promise<void>((resolve) => {
+      release = resolve
+    })
+    void withSidecarSnapshotQueue(join(root, fileOf('session:0')), () => held)
+    void withSidecarSnapshotQueue(join(root, fileOf('session:garbage')), () => held)
+    const store = createNativeChatDraftStore(root)
+    const oldest = store.write('session:0', draft('typed after relaunch'))
+    const overGarbage = store.write('session:garbage', draft('typed over garbage'))
+    const loaded = store.load()
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    release()
+    await loaded
+
+    expect(await oldest).toBe('persisted')
+    expect(await overGarbage).toBe('persisted')
+    const next = new Map(
+      (await createNativeChatDraftStore(root).load()).map(({ scopeKey, draft }) => [
+        scopeKey,
+        draft
+      ])
+    )
+    expect(next.get('session:0')).toEqual(draft('typed after relaunch'))
+    expect(next.get('session:garbage')).toEqual(draft('typed over garbage'))
+  })
+
+  it('keeps only the newest drafts past the bound', async () => {
+    const root = await freshRoot()
+    const store = createNativeChatDraftStore(root)
+    for (let index = 0; index < 130; index += 1) {
+      await store.write(`session:${index}`, draft(`draft-${index}`))
+      if (index < 2) {
+        // The two oldest are written in earlier milliseconds than the rest.
+        await new Promise((resolve) => setTimeout(resolve, 5))
+      }
+    }
+
+    const loaded = await createNativeChatDraftStore(root).load()
+
+    expect(loaded).toHaveLength(128)
+    expect(loaded.map(({ scopeKey }) => scopeKey)).not.toContain('session:0')
+    expect(loaded.map(({ scopeKey }) => scopeKey)).not.toContain('session:1')
+    expect((await readdir(root)).filter((name) => name.endsWith('.json'))).toHaveLength(128)
+  })
+
+  it('reports a failed write without throwing', async () => {
+    const root = await freshRoot()
+    await writeFile(join(root, '..', 'blocker'), '')
+    const store = createNativeChatDraftStore(join(root, '..', 'blocker', 'drafts'))
+
+    await expect(store.write('session:s1', draft('hello'))).resolves.toBe('failed')
+  })
+})
diff --git a/src/main/native-chat/native-chat-draft-store.ts b/src/main/native-chat/native-chat-draft-store.ts
new file mode 100644
index 00000000000..1f3243b7b80
--- /dev/null
+++ b/src/main/native-chat/native-chat-draft-store.ts
@@ -0,0 +1,285 @@
+// Composer drafts kept by the main process, one sidecar file per chat. A clear deletes the file
+// and a write renames a temp file over it, so once either returned it survives the app being
+// killed. No fsync: a power loss can still lose the last seconds, as browser storage would.
+
+import { createHash } from 'node:crypto'
+import { readdirSync, readFileSync } from 'node:fs'
+import { mkdir, readdir, readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { removeStaleDurableWriteTempFiles } from '../durable-file-write'
+import {
+  removeSidecarSnapshot,
+  sidecarSnapshotFile,
+  withSidecarSnapshotQueue,
+  writeSidecarSnapshot
+} from '../sidecar-snapshot-file'
+import {
+  isEmptyNativeChatDraft,
+  parseNativeChatDraft,
+  type NativeChatDraftStoreResult,
+  type PersistedNativeChatDraft,
+  type SavedNativeChatDraft
+} from '../../shared/native-chat-draft-record'
+
+const FILE_VERSION = 1
+// Why a cap at load: drafts die with their chat; this bounds those whose end this client missed.
+const MAX_SAVED_DRAFTS = 128
+
+type Saved = { draft: PersistedNativeChatDraft; savedAt: number }
+type Intent = { draft: PersistedNativeChatDraft | null; savedAt: number }
+
+type DraftFile =
+  | ({ kind: 'draft'; scopeKey: string } & Saved)
+  /** Not JSON, JSON with no newer version, or a version-1 file that is not a draft. */
+  | { kind: 'garbage' }
+  /** A newer build's draft, or a file that could not be read this time: never deleted. */
+  | { kind: 'kept'; reason: string }
+  | { kind: 'gone' }
+
+export type NativeChatDraftStore = {
+  /** Every saved draft, oldest first, once the writes already asked for have landed. */
+  load: () => Promise<SavedNativeChatDraft[]>
+  /** The same without waiting, for a renderer that needs drafts before an async load returned. */
+  loadSync: () => SavedNativeChatDraft[]
+  /** Resolves once the file op returned. Writes for one chat apply in the order they arrived. */
+  write: (
+    scopeKey: string,
+    draft: PersistedNativeChatDraft | null
+  ) => Promise<NativeChatDraftStoreResult>
+  /** Waits for every write asked for so far, then retries each failed one once (at quit). */
+  drain: () => Promise<void>
+}
+
+function draftFile(root: string, scopeKey: string): string {
+  // Why hashed: a pane key holds ':', which Windows refuses in a file name.
+  return sidecarSnapshotFile(root, `${createHash('sha256').update(scopeKey).digest('hex')}.json`)
+}
+
+function classifyDraftFile(raw: string): DraftFile {
+  let value: unknown
+  try {
+    value = JSON.parse(raw)
+  } catch {
+    return { kind: 'garbage' }
+  }
+  const v = typeof value === 'object' && value !== null && 'v' in value ? value.v : undefined
+  if (typeof v === 'number' && v > FILE_VERSION) {
+    return { kind: 'kept', reason: `version ${v}` }
+  }
+  if (v !== FILE_VERSION) {
+    return { kind: 'garbage' }
+  }
+  const scopeKey =
+    typeof value === 'object' && value !== null && 'scopeKey' in value && value.scopeKey
+  const savedAt = typeof value === 'object' && value !== null && 'savedAt' in value && value.savedAt
+  const draft = parseNativeChatDraft(value)
+  return typeof scopeKey === 'string' && draft
+    ? { kind: 'draft', scopeKey, draft, savedAt: typeof savedAt === 'number' ? savedAt : 0 }
+    : { kind: 'garbage' }
+}
+
+function errorCode(error: unknown): string {
+  return error instanceof Error && 'code' in error ? String(error.code) : 'unknown'
+}
+
+async function readDraftFile(file: string): Promise<DraftFile> {
+  try {
+    return classifyDraftFile(await readFile(file, 'utf8'))
+  } catch (error) {
+    const code = errorCode(error)
+    return code === 'ENOENT' ? { kind: 'gone' } : { kind: 'kept', reason: code }
+  }
+}
+
+function oldestFirst(saved: Iterable<[string, Saved]>): SavedNativeChatDraft[] {
+  return Array.from(saved)
+    .sort((left, right) => left[1].savedAt - right[1].savedAt)
+    .map(([scopeKey, { draft }]) => ({ scopeKey, draft }))
+}
+
+export function createNativeChatDraftStore(root: string): NativeChatDraftStore {
+  // What each chat's draft should be, failed writes included, so a reloaded window never sees
+  // text whose clear did not reach the file.
+  const saved = new Map<string, Saved>()
+  const written = new Set<string>()
+  const pending = new Set<Promise<unknown>>()
+  // The newest write per chat, so an older failure never outlives a newer write.
+  const latest = new Map<string, Intent>()
+  // A write whose file op failed: superseded by the chat's next write, else retried once at quit.
+  const failed = new Map<string, Intent>()
+  let rootReady: Promise<unknown> | null = null
+  let loaded = false
+
+  const track = <T>(work: Promise<T>): Promise<T> => {
+    pending.add(work)
+    void work.then(
+      () => pending.delete(work),
+      () => pending.delete(work)
+    )
+    return work
+  }
+
+  // Load-time deletes go through the chat's queue and recheck, so they never undo a write.
+  const removeIfStill = (file: string, stillDoomed: () => Promise<boolean> | boolean) =>
+    withSidecarSnapshotQueue(file, async () => {
+      if (await stillDoomed()) {
+        await removeSidecarSnapshot(file)
+      }
+    }).catch((error: unknown) => console.warn('[native-chat-drafts] could not delete', file, error))
+
+  const ready = (async () => {
+    const found: ({ file: string; scopeKey: string } & Saved)[] = []
+    const removals: Promise<void>[] = []
+    const names = await readdir(root).catch(() => [])
+    // Temp files a killed run left mid-write; this run's own are never swept.
+    const interrupted = new Set(
+      names.filter((name) => name.endsWith('.tmp')).map((name) => name.split('.json.')[0])
+    )
+    await Promise.all(
+      Array.from(interrupted, (hash) =>
+        removeStaleDurableWriteTempFiles(join(root, `${hash}.json`))
+      )
+    )
+    for (const name of names.filter((entry) => entry.endsWith('.json'))) {
+      const file = join(root, name)
+      const read = await readDraftFile(file)
+      switch (read.kind) {
+        case 'draft':
+          found.push({ ...read, file })
+          break
+        case 'garbage':
+          removals.push(
+            removeIfStill(file, async () => (await readDraftFile(file)).kind === 'garbage')
+          )
+          break
+        case 'kept':
+          console.warn('[native-chat-drafts] kept a draft file it cannot use:', name, read.reason)
+          break
+        case 'gone':
+          break
+      }
+    }
+    found.sort((left, right) => left.savedAt - right.savedAt)
+    for (const [index, entry] of found.entries()) {
+      if (written.has(entry.scopeKey)) {
+        continue
+      }
+      if (index < found.length - MAX_SAVED_DRAFTS) {
+        removals.push(removeIfStill(entry.file, () => !written.has(entry.scopeKey)))
+      } else {
+        saved.set(entry.scopeKey, { draft: entry.draft, savedAt: entry.savedAt })
+      }
+    }
+    await Promise.all(removals)
+    loaded = true
+  })()
+
+  const apply = async (scopeKey: string, { draft, savedAt }: Intent): Promise<void> => {
+    const file = draftFile(root, scopeKey)
+    if (!draft || isEmptyNativeChatDraft(draft)) {
+      await removeSidecarSnapshot(file)
+      return
+    }
+    // Why once: a mkdir per typing pause queues ahead of the clear; any failure makes it again.
+    rootReady ??= mkdir(root, { recursive: true, mode: 0o700 })
+    try {
+      await rootReady
+      await writeSidecarSnapshot(
+        file,
+        { v: FILE_VERSION, scopeKey, savedAt, ...draft },
+        { durability: 'process' }
+      )
+    } catch (error) {
+      rootReady = null
+      throw error
+    }
+  }
+
+  const settle = async (): Promise<void> => {
+    await Promise.all(pending)
+  }
+
+  return {
+    load: async () => {
+      await ready
+      await settle()
+      return oldestFirst(saved)
+    },
+    loadSync: () => {
+      if (loaded) {
+        return oldestFirst(saved)
+      }
+      const found: [string, Saved][] = []
+      let names: string[] = []
+      try {
+        names = readdirSync(root).filter((entry) => entry.endsWith('.json'))
+      } catch {
+        // No drafts folder yet.
+      }
+      for (const name of names) {
+        try {
+          const read = classifyDraftFile(readFileSync(join(root, name), 'utf8'))
+          if (read.kind === 'draft') {
+            found.push([read.scopeKey, read])
+          }
+        } catch {
+          // Unreadable for now: skipped here, judged by the async load.
+        }
+      }
+      return oldestFirst(found).slice(-MAX_SAVED_DRAFTS)
+    },
+    write: (scopeKey, draft) => {
+      written.add(scopeKey)
+      failed.delete(scopeKey)
+      const intent: Intent = { draft, savedAt: Date.now() }
+      latest.set(scopeKey, intent)
+      if (draft && !isEmptyNativeChatDraft(draft)) {
+        saved.set(scopeKey, { draft, savedAt: intent.savedAt })
+      } else {
+        saved.delete(scopeKey)
+      }
+      // Why queued per chat: a typing write still in flight must never land after the clear behind it.
+      return track(
+        withSidecarSnapshotQueue(draftFile(root, scopeKey), () => apply(scopeKey, intent)).then(
+          (): NativeChatDraftStoreResult => {
+            if (latest.get(scopeKey) === intent) {
+              latest.delete(scopeKey)
+            }
+            return 'persisted'
+          },
+          (error: unknown): NativeChatDraftStoreResult => {
+            if (latest.get(scopeKey) === intent) {
+              failed.set(scopeKey, intent)
+            }
+            console.warn(
+              '[native-chat-drafts] write failed; retrying at its next write or at quit:',
+              errorCode(error)
+            )
+            return 'failed'
+          }
+        )
+      )
+    },
+    drain: async () => {
+      await settle()
+      const retries = Array.from(failed)
+      failed.clear()
+      await Promise.all(
+        retries.map(([scopeKey, intent]) =>
+          withSidecarSnapshotQueue(draftFile(root, scopeKey), () => apply(scopeKey, intent)).then(
+            () => {
+              if (latest.get(scopeKey) === intent) {
+                latest.delete(scopeKey)
+              }
+            },
+            (error: unknown) =>
+              console.warn(
+                '[native-chat-drafts] dropped a draft write that failed twice:',
+                errorCode(error)
+              )
+          )
+        )
+      )
+    }
+  }
+}
diff --git a/src/main/sidecar-snapshot-file.test.ts b/src/main/sidecar-snapshot-file.test.ts
index 7df50763602..45f956cac22 100644
--- a/src/main/sidecar-snapshot-file.test.ts
+++ b/src/main/sidecar-snapshot-file.test.ts
@@ -1,9 +1,58 @@
-import { describe, expect, it } from 'vitest'
+import { mkdtemp, readdir, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type * as NodeFsPromises from 'node:fs/promises'
+import type * as DurableFileWrite from './durable-file-write'
+
+const durable = vi.hoisted(() => ({
+  writeFileDurable: vi.fn(),
+  writeFileProcessDurable: vi.fn(),
+  removeStaleDurableWriteTempFiles: vi.fn()
+}))
+
+const fsPromises = vi.hoisted(() => ({ rm: vi.fn() }))
+
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof NodeFsPromises>()
+  fsPromises.rm.mockImplementation(actual.rm)
+  return { ...actual, rm: fsPromises.rm }
+})
+
+vi.mock('./durable-file-write', async (importOriginal) => {
+  const actual = await importOriginal<typeof DurableFileWrite>()
+  durable.writeFileDurable.mockImplementation(actual.writeFileDurable)
+  durable.writeFileProcessDurable.mockImplementation(actual.writeFileProcessDurable)
+  durable.removeStaleDurableWriteTempFiles.mockImplementation(
+    actual.removeStaleDurableWriteTempFiles
+  )
+  return { ...actual, ...durable }
+})
+
 import {
   _getSidecarSnapshotPendingFileCountForTests,
-  withSidecarSnapshotQueue
+  readSidecarSnapshot,
+  removeSidecarSnapshot,
+  withSidecarSnapshotQueue,
+  writeSidecarSnapshot
 } from './sidecar-snapshot-file'
 
+const roots: string[] = []
+
+async function freshRoot(): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), 'orca-sidecar-snapshot-'))
+  roots.push(root)
+  return root
+}
+
+const originalPlatform = process.platform
+
+afterEach(async () => {
+  Object.defineProperty(process, 'platform', { value: originalPlatform })
+  vi.clearAllMocks()
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
+})
+
 describe('sidecar snapshot queues', () => {
   it('releases completed per-file queue entries', async () => {
     await Promise.all(
@@ -16,3 +65,61 @@ describe('sidecar snapshot queues', () => {
     expect(_getSidecarSnapshotPendingFileCountForTests()).toBe(0)
   })
 })
+
+describe('sidecar snapshot writes', () => {
+  it('flushes to disk by default, as every existing caller expects', async () => {
+    const file = join(await freshRoot(), 'snapshot.json')
+
+    await writeSidecarSnapshot(file, { a: 1 })
+
+    expect(durable.writeFileDurable).toHaveBeenCalledOnce()
+    expect(durable.writeFileProcessDurable).not.toHaveBeenCalled()
+    expect(await readSidecarSnapshot(file)).toEqual({ a: 1 })
+  })
+
+  it("skips the disk flush only when asked for 'process' durability", async () => {
+    const file = join(await freshRoot(), 'snapshot.json')
+
+    await writeSidecarSnapshot(file, { a: 1 }, { durability: 'process' })
+
+    expect(durable.writeFileProcessDurable).toHaveBeenCalledOnce()
+    expect(durable.writeFileDurable).not.toHaveBeenCalled()
+    expect(await readSidecarSnapshot(file)).toEqual({ a: 1 })
+  })
+
+  // Only a crashed run leaves temp files; listing the folder on every write only adds latency.
+  it("sweeps a file's stale temp files once per run, not on every write", async () => {
+    const file = join(await freshRoot(), 'snapshot.json')
+
+    await writeSidecarSnapshot(file, { a: 1 }, { durability: 'process' })
+    await writeSidecarSnapshot(file, { a: 2 }, { durability: 'process' })
+    await writeSidecarSnapshot(file, { a: 3 })
+
+    expect(durable.removeStaleDurableWriteTempFiles).toHaveBeenCalledOnce()
+    expect(await readSidecarSnapshot(file)).toEqual({ a: 3 })
+  })
+
+  it('removes a snapshot, and treats a missing one as removed', async () => {
+    const root = await freshRoot()
+    const file = join(root, 'snapshot.json')
+    await writeSidecarSnapshot(file, { a: 1 }, { durability: 'process' })
+
+    await withSidecarSnapshotQueue(file, () => removeSidecarSnapshot(file))
+    await expect(removeSidecarSnapshot(file)).resolves.toBeUndefined()
+
+    expect(await readdir(root)).toEqual([])
+  })
+
+  // A virus scanner holding a just-written draft open must not fail the clear at send (#1507).
+  it('retries a delete Windows refused while another process held the file', async () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' })
+    const root = await freshRoot()
+    const file = join(root, 'snapshot.json')
+    await writeSidecarSnapshot(file, { a: 1 }, { durability: 'process' })
+    fsPromises.rm.mockRejectedValueOnce(Object.assign(new Error('busy'), { code: 'EBUSY' }))
+
+    await removeSidecarSnapshot(file)
+
+    expect(await readdir(root)).toEqual([])
+  })
+})
diff --git a/src/main/sidecar-snapshot-file.ts b/src/main/sidecar-snapshot-file.ts
index 4ee5c2dfa5c..6e8087b7662 100644
--- a/src/main/sidecar-snapshot-file.ts
+++ b/src/main/sidecar-snapshot-file.ts
@@ -6,11 +6,15 @@ import { join } from 'node:path'
 import {
   durableWriteTempPath,
   removeStaleDurableWriteTempFiles,
-  writeFileDurable
+  writeFileDurable,
+  writeFileProcessDurable
 } from './durable-file-write'
+import { removeFileWithWindowsRetryAsync } from './codex-accounts/fs-utils'
 
 const queues = new Map<string, Promise<unknown>>()
 const staleTempCleanups = new Map<string, Promise<void>>()
+// Why once per run: only a crashed run leaves temp files, so sweeping again finds nothing.
+const sweptFiles = new Set<string>()
 const STALE_TEMP_AGE_MS = 24 * 60 * 60 * 1000
 
 export function sidecarSnapshotFile(snapshotDirectory: string, fileName: string): string {
@@ -43,19 +47,36 @@ export async function readSidecarSnapshot(file: string): Promise<unknown> {
   }
 }
 
-export async function writeSidecarSnapshot(file: string, payload: unknown): Promise<void> {
-  let cleanup = staleTempCleanups.get(file)
-  if (!cleanup) {
-    cleanup = removeStaleDurableWriteTempFiles(file, { minimumAgeMs: STALE_TEMP_AGE_MS })
-    staleTempCleanups.set(file, cleanup)
-    void cleanup.then(() => {
-      if (staleTempCleanups.get(file) === cleanup) {
-        staleTempCleanups.delete(file)
-      }
-    })
+/**
+ * `durability: 'process'` skips fsync: the write survives the app being killed but not a power
+ * loss, for sidecars written on a latency-sensitive path.
+ */
+export async function writeSidecarSnapshot(
+  file: string,
+  payload: unknown,
+  options: { durability?: 'power-loss' | 'process' } = {}
+): Promise<void> {
+  if (!sweptFiles.has(file)) {
+    let cleanup = staleTempCleanups.get(file)
+    if (!cleanup) {
+      cleanup = removeStaleDurableWriteTempFiles(file, { minimumAgeMs: STALE_TEMP_AGE_MS })
+      staleTempCleanups.set(file, cleanup)
+      void cleanup.then(() => {
+        sweptFiles.add(file)
+        if (staleTempCleanups.get(file) === cleanup) {
+          staleTempCleanups.delete(file)
+        }
+      })
+    }
+    await cleanup
   }
-  await cleanup
-  await writeFileDurable(durableWriteTempPath(file), file, JSON.stringify(payload))
+  const write = options.durability === 'process' ? writeFileProcessDurable : writeFileDurable
+  await write(durableWriteTempPath(file), file, JSON.stringify(payload))
+}
+
+/** Delete a sidecar; a missing one is already removed. Run it inside the file's queue. */
+export async function removeSidecarSnapshot(file: string): Promise<void> {
+  await removeFileWithWindowsRetryAsync(file)
 }
 
 export function _getSidecarSnapshotPendingFileCountForTests(): number {
diff --git a/src/main/startup/desktop-startup-ordering.test.ts b/src/main/startup/desktop-startup-ordering.test.ts
index ce8148ea5d2..6365ebba727 100644
--- a/src/main/startup/desktop-startup-ordering.test.ts
+++ b/src/main/startup/desktop-startup-ordering.test.ts
@@ -50,6 +50,23 @@ describe('startup ordering', () => {
     expect(willQuit.slice(barrierStart)).toContain("{ name: 'browser', promise: browserShutdown }")
   })
 
+  // A chat's clear at send, still being written as Orca quits, must land before it exits.
+  it('waits for native chat draft writes before the committed quit exits', () => {
+    const source = readFileSync(
+      join(process.cwd(), 'src/main/startup/main-process-quit.ts'),
+      'utf8'
+    )
+    const willQuitStart = source.indexOf("app.on('will-quit'")
+    const windowAllClosedStart = source.indexOf("app.on('window-all-closed'", willQuitStart)
+    const willQuit = source.slice(willQuitStart, windowAllClosedStart)
+    const barrierStart = willQuit.indexOf('settleTeardownWithinDeadline([')
+
+    expect(barrierStart).toBeGreaterThanOrEqual(0)
+    expect(willQuit.slice(barrierStart)).toContain(
+      "{ name: 'native-chat-drafts', promise: drainNativeChatDrafts() }"
+    )
+  })
+
   it('registers repeatable serve signal handling before headless startup completes', () => {
     const source = readFileSync(
       join(process.cwd(), 'src/main/startup/main-process-runtime-launch.ts'),
diff --git a/src/main/startup/main-process-quit.ts b/src/main/startup/main-process-quit.ts
index 5a89c9e283f..3535f4443fb 100644
--- a/src/main/startup/main-process-quit.ts
+++ b/src/main/startup/main-process-quit.ts
@@ -32,6 +32,7 @@ import { shouldQuitWhenAllWindowsClosed } from './window-all-closed-quit-policy'
 import { mainProcessState as state } from './main-process-state'
 import { isDevParentShutdownRequested } from './configure-process'
 import { getCanonicalUserDataPath } from '../persistence'
+import { drainNativeChatDrafts } from '../ipc/native-chat-drafts'
 
 // Why: will-quit fires twice — first pass preventDefaults and runs teardown; second pass exits.
 let daemonDisconnectDone = false
@@ -270,6 +271,7 @@ function installWillQuitHandler(): void {
       { name: 'structured-agent-session', promise: structuredAgentSessionShutdown },
       { name: 'usage-cache', promise: usageCacheFlush },
       { name: 'stats', promise: statsFlush },
+      { name: 'native-chat-drafts', promise: drainNativeChatDrafts() },
       { name: 'state', promise: storeFlush }
     ])
       .then((pendingTeardowns) => {
diff --git a/src/main/window/clipboard-image-temp-file.test.ts b/src/main/window/clipboard-image-temp-file.test.ts
index 71ca0804c0e..6cfdb223e77 100644
--- a/src/main/window/clipboard-image-temp-file.test.ts
+++ b/src/main/window/clipboard-image-temp-file.test.ts
@@ -1,13 +1,18 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { authorizeExternalPathMock, writeFileMock, getPathMock, writeFileBase64Mock } = vi.hoisted(
-  () => ({
-    authorizeExternalPathMock: vi.fn(),
-    writeFileMock: vi.fn(),
-    getPathMock: vi.fn(() => '/var/folders/ab/T'),
-    writeFileBase64Mock: vi.fn()
-  })
-)
+const {
+  authorizeExternalPathMock,
+  writeFileMock,
+  getPathMock,
+  writeFileBase64Mock,
+  saveNativeChatAttachmentFileMock
+} = vi.hoisted(() => ({
+  authorizeExternalPathMock: vi.fn(),
+  writeFileMock: vi.fn(),
+  getPathMock: vi.fn(() => '/var/folders/ab/T'),
+  writeFileBase64Mock: vi.fn(),
+  saveNativeChatAttachmentFileMock: vi.fn(async (fileName: string) => `/user-data/chat/${fileName}`)
+}))
 
 vi.mock('node:fs/promises', () => ({ default: { writeFile: writeFileMock } }))
 vi.mock('node:crypto', () => ({ randomUUID: () => 'uuid-1' }))
@@ -21,6 +26,9 @@ vi.mock('../providers/ssh-filesystem-dispatch', () => ({
   })
 }))
 vi.mock('../ipc/filesystem-auth', () => ({ authorizeExternalPath: authorizeExternalPathMock }))
+vi.mock('./native-chat-attachment-store', () => ({
+  saveNativeChatAttachmentFile: saveNativeChatAttachmentFileMock
+}))
 
 import { saveClipboardImageBufferAsTempFile } from './clipboard-image-temp-file'
 
@@ -47,4 +55,18 @@ describe('saveClipboardImageBufferAsTempFile', () => {
     expect(writeFileBase64Mock).toHaveBeenCalled()
     expect(authorizeExternalPathMock).not.toHaveBeenCalled()
   })
+
+  // A chat draft can hold the image across a reboot, which OS temp does not survive.
+  it("keeps a chat attachment in Orca's attachment storage, not OS temp", async () => {
+    const savedPath = await saveClipboardImageBufferAsTempFile(Buffer.from([1]), {
+      chatAttachment: true
+    })
+
+    expect(savedPath.startsWith('/user-data/chat/orca-paste-')).toBe(true)
+    expect(saveNativeChatAttachmentFileMock).toHaveBeenCalledWith(
+      expect.stringMatching(/^orca-paste-.+\.png$/),
+      Buffer.from([1])
+    )
+    expect(writeFileMock).not.toHaveBeenCalled()
+  })
 })
diff --git a/src/main/window/clipboard-image-temp-file.ts b/src/main/window/clipboard-image-temp-file.ts
index 0024c4b6d1f..8c82ebbcced 100644
--- a/src/main/window/clipboard-image-temp-file.ts
+++ b/src/main/window/clipboard-image-temp-file.ts
@@ -7,10 +7,13 @@ import { requireSshFilesystemProvider } from '../providers/ssh-filesystem-dispat
 import { isWindowsAbsolutePathLike } from '../../shared/cross-platform-path'
 import { assertClipboardImageByteLengthWithinLimit } from '../../shared/clipboard-image'
 import { authorizeExternalPath } from '../ipc/filesystem-auth'
+import { saveNativeChatAttachmentFile } from './native-chat-attachment-store'
 
 export type SaveClipboardImageAsTempFileArgs = {
   connectionId?: string | null
   runtimeEnvironmentId?: string | null
+  /** A chat attachment can sit in a saved draft across a reboot, so it is kept out of OS temp. */
+  chatAttachment?: boolean
 }
 
 const REMOTE_CLIPBOARD_IMAGE_TEMP_DIR = '/tmp'
@@ -40,6 +43,10 @@ export async function saveClipboardImageBufferAsTempFile(
     return remotePath
   }
 
+  if (args?.chatAttachment) {
+    return saveNativeChatAttachmentFile(fileName, buffer)
+  }
+
   const tempPath = path.join(getAppEnvironment().getPath('temp'), fileName)
   await fs.writeFile(tempPath, buffer)
   // Why: the OS temp dir is outside every allowed root, so without this the
diff --git a/src/main/window/clipboard-ipc-handlers.ts b/src/main/window/clipboard-ipc-handlers.ts
index e81140d734a..b61de8d0485 100644
--- a/src/main/window/clipboard-ipc-handlers.ts
+++ b/src/main/window/clipboard-ipc-handlers.ts
@@ -43,6 +43,7 @@ import { readClipboardCopiedFilePaths } from './clipboard-copied-file-paths'
 import { buildClipboardImageThumbnail } from './clipboard-image-thumbnail'
 import { writeClipboardTextAndVerify } from './clipboard-text-write-verify'
 import { isDashboardPopoutRenderer } from './dashboard-popout-window'
+import { scheduleNativeChatAttachmentSweep } from './native-chat-attachment-store'
 
 let trustedClipboardRendererWebContentsId: number | null = null
 
@@ -103,6 +104,7 @@ export function registerClipboardHandlers(store: Store): void {
 
   void cleanupExpiredRemoteClipboardFiles()
   scheduleLegacyRemoteClipboardFileCleanup()
+  scheduleNativeChatAttachmentSweep()
 
   ipcMain.handle('clipboard:readText', async (event, options?: ReadClipboardTextOptions) => {
     assertTrustedClipboardTextSender(event)
diff --git a/src/main/window/dragged-temp-file-copy.ts b/src/main/window/dragged-temp-file-copy.ts
index cacd4f4c9c5..09f9615fe09 100644
--- a/src/main/window/dragged-temp-file-copy.ts
+++ b/src/main/window/dragged-temp-file-copy.ts
@@ -23,7 +23,7 @@ const TEMPORARY_ITEMS_SEGMENT = 'TemporaryItems'
 const DRAG_PROVIDER_DIR_PREFIX = 'NSIRD_'
 const COPY_ROOT_NAME = 'orca-drops'
 const COPY_DIR_PREFIX = 'orca-drop-'
-const COPY_DIR_PATTERN = /^orca-drop-[A-Za-z0-9]{6}$/
+export const DRAG_TEMP_COPY_DIR_PATTERN = /^orca-drop-[A-Za-z0-9]{6}$/
 // Why: open drafts and startup prompts read the copy lazily, often days later, so
 // keep it well past the drop; the TTL still bounds what the copy budget holds.
 export const DRAG_TEMP_COPY_TTL_MS = 7 * 24 * 60 * 60 * 1000
@@ -36,6 +36,8 @@ export type DragTempCopyEnvironment = {
   sourceTempRoot: string
   /** Orca-owned directory that holds one `orca-drop-*` directory per copy. */
   copyRoot: string
+  /** Creates or accepts `copyRoot`; the default demands a private root, as a shared temp dir needs. */
+  prepareCopyRoot?: (copyRoot: string) => Promise<boolean>
 }
 
 export type DragTempCopyItemResult =
@@ -158,7 +160,7 @@ export async function materializeDragTempPath(
       }
       signal?.throwIfAborted()
 
-      copyDir = await createCopyDirectory(env.copyRoot)
+      copyDir = await createCopyDirectory(env)
       const destPath = join(copyDir, basename(canonicalSource))
       // Why: stream from the checked handle, capped at the inspected size, so a
       // swapped or growing source cannot slip through; unlike cp, ditto or
@@ -211,7 +213,7 @@ export async function sweepExpiredDragTempCopies(
   await sweepExpiredOwnedDirectories(copyRoot, {
     nowMs,
     ttlMs: DRAG_TEMP_COPY_TTL_MS,
-    ownsEntry: (name) => COPY_DIR_PATTERN.test(name)
+    ownsEntry: (name) => DRAG_TEMP_COPY_DIR_PATTERN.test(name)
   })
 }
 
@@ -226,7 +228,7 @@ async function measureRetainedCopyBytes(copyRoot: string): Promise<number> {
   }
   try {
     for await (const entry of rootDir) {
-      if (!entry.isDirectory() || !COPY_DIR_PATTERN.test(entry.name)) {
+      if (!entry.isDirectory() || !DRAG_TEMP_COPY_DIR_PATTERN.test(entry.name)) {
         continue
       }
       const copyDir = join(copyRoot, entry.name)
@@ -293,12 +295,12 @@ function isPathWithin(root: string, candidate: string): boolean {
   return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel))
 }
 
-async function createCopyDirectory(copyRoot: string): Promise<string> {
+async function createCopyDirectory(env: DragTempCopyEnvironment): Promise<string> {
   try {
-    if (!(await ensureOwnedTempStagingRoot(copyRoot))) {
+    if (!(await (env.prepareCopyRoot ?? ensureOwnedTempStagingRoot)(env.copyRoot))) {
       throw new DropCopyError('storage-not-private')
     }
-    return await mkdtemp(join(copyRoot, COPY_DIR_PREFIX))
+    return await mkdtemp(join(env.copyRoot, COPY_DIR_PREFIX))
   } catch (error) {
     if (error instanceof DropCopyError) {
       throw error
diff --git a/src/main/window/native-chat-attachment-store.test.ts b/src/main/window/native-chat-attachment-store.test.ts
new file mode 100644
index 00000000000..e46c11bc6d6
--- /dev/null
+++ b/src/main/window/native-chat-attachment-store.test.ts
@@ -0,0 +1,115 @@
+import {
+  chmod,
+  lstat,
+  mkdir,
+  mkdtemp,
+  readdir,
+  readFile,
+  realpath,
+  rm,
+  symlink,
+  utimes,
+  writeFile
+} from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { basename, dirname, join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { setAppEnvironment, type AppEnvironment } from '../../shared/app-environment'
+import { materializeDragTempPaths } from './dragged-temp-file-copy'
+import type { Store } from '../persistence'
+import { resolveAuthorizedPath } from '../ipc/filesystem-auth'
+import {
+  ensureNativeChatAttachmentRoot,
+  getNativeChatAttachmentRoot,
+  NATIVE_CHAT_ATTACHMENT_TTL_MS,
+  saveNativeChatAttachmentFile,
+  sweepExpiredNativeChatAttachments
+} from './native-chat-attachment-store'
+
+let userData: string
+
+beforeEach(async () => {
+  userData = await mkdtemp(join(tmpdir(), 'orca-chat-attachments-'))
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the store reads only getPath.
+  setAppEnvironment({ getPath: () => userData } as unknown as AppEnvironment)
+})
+
+afterEach(async () => {
+  await rm(userData, { recursive: true, force: true })
+})
+
+describe('native chat attachment storage', () => {
+  it('keeps each image in its own directory under user data', async () => {
+    const saved = await saveNativeChatAttachmentFile('orca-paste-1.png', Buffer.from([7]))
+
+    expect(dirname(dirname(saved))).toBe(getNativeChatAttachmentRoot())
+    expect(getNativeChatAttachmentRoot().startsWith(userData)).toBe(true)
+    expect(await readFile(saved)).toEqual(Buffer.from([7]))
+  })
+
+  // Nothing authorized it in this process: a relaunch forgets every per-file grant.
+  it('lets a restored draft read its image with no grant from this session', async () => {
+    const saved = await saveNativeChatAttachmentFile('orca-paste-1.png', Buffer.from([7]))
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: with no repos and no workspace dir, authorization reads only these two.
+    const store = { getRepos: () => [], getSettings: () => ({}) } as unknown as Store
+
+    await expect(resolveAuthorizedPath(saved, store)).resolves.toBe(await realpath(saved))
+  })
+
+  // User data is already per user; a restored or mode-less root must not stop every paste.
+  it('saves into a root that is not private, but never through a symlinked one', async () => {
+    await mkdir(getNativeChatAttachmentRoot(), { mode: 0o755 })
+    await chmod(getNativeChatAttachmentRoot(), 0o755)
+    const saved = await saveNativeChatAttachmentFile('orca-paste-1.png', Buffer.from([7]))
+    expect(await readFile(saved)).toEqual(Buffer.from([7]))
+
+    await rm(getNativeChatAttachmentRoot(), { recursive: true })
+    const elsewhere = await mkdtemp(join(tmpdir(), 'orca-chat-elsewhere-'))
+    await symlink(elsewhere, getNativeChatAttachmentRoot())
+    await expect(
+      saveNativeChatAttachmentFile('orca-paste-2.png', Buffer.from([7]))
+    ).rejects.toThrow()
+    await rm(elsewhere, { recursive: true, force: true })
+  })
+
+  // A paste usually creates the folder first; a composer drop must still copy into it.
+  it.skipIf(process.platform === 'win32')(
+    'creates the folder owner-only, and a composer drop copies into it after a paste',
+    async () => {
+      await saveNativeChatAttachmentFile('orca-paste-1.png', Buffer.from([7]))
+      expect((await lstat(getNativeChatAttachmentRoot())).mode & 0o777).toBe(0o700)
+      await chmod(getNativeChatAttachmentRoot(), 0o755)
+      const sourceTempRoot = join(userData, 'T')
+      const dragged = join(sourceTempRoot, 'TemporaryItems', 'NSIRD_screencaptureui_1', 'Shot.png')
+      await mkdir(dirname(dragged), { recursive: true })
+      await writeFile(dragged, Buffer.from([9]))
+
+      const [result] = await materializeDragTempPaths([dragged], {
+        platform: 'darwin',
+        sourceTempRoot,
+        copyRoot: getNativeChatAttachmentRoot(),
+        prepareCopyRoot: ensureNativeChatAttachmentRoot
+      })
+
+      expect(result).toMatchObject({ status: 'imported' })
+      expect(result?.status === 'imported' && dirname(dirname(result.destPath))).toBe(
+        getNativeChatAttachmentRoot()
+      )
+    }
+  )
+
+  it('sweeps pastes and drag copies past the age limit, and keeps younger ones', async () => {
+    const old = await saveNativeChatAttachmentFile('orca-paste-old.png', Buffer.from([1]))
+    const fresh = await saveNativeChatAttachmentFile('orca-paste-new.png', Buffer.from([2]))
+    const oldDrop = join(getNativeChatAttachmentRoot(), 'orca-drop-abc123')
+    await mkdir(oldDrop, { mode: 0o700 })
+    const now = Date.now()
+    const expired = new Date(now - NATIVE_CHAT_ATTACHMENT_TTL_MS - 1000)
+    await utimes(dirname(old), expired, expired)
+    await utimes(oldDrop, expired, expired)
+
+    await sweepExpiredNativeChatAttachments(now)
+
+    expect(await readdir(getNativeChatAttachmentRoot())).toEqual([basename(dirname(fresh))])
+  })
+})
diff --git a/src/main/window/native-chat-attachment-store.ts b/src/main/window/native-chat-attachment-store.ts
new file mode 100644
index 00000000000..b2d1be74ca1
--- /dev/null
+++ b/src/main/window/native-chat-attachment-store.ts
@@ -0,0 +1,86 @@
+import { lstat, mkdir, mkdtemp, writeFile } from 'node:fs/promises'
+import { join, resolve } from 'node:path'
+import { getAppEnvironment, hasAppEnvironment } from '../../shared/app-environment'
+import { DRAG_TEMP_COPY_DIR_PATTERN } from './dragged-temp-file-copy'
+import { sweepExpiredOwnedDirectories } from './owned-temp-staging-root'
+
+// Images pasted or dropped (macOS drag copies) into a chat live here rather than in OS temp, so
+// a draft restored after a reboot still names a real file. One directory per image, swept by age.
+const ATTACHMENT_ROOT_NAME = 'native-chat-attachments'
+const ATTACHMENT_DIR_PREFIX = 'chat-image-'
+const ATTACHMENT_DIR_PATTERN = /^chat-image-[A-Za-z0-9]{6}$/
+// Why: an unsent draft can wait weeks; past this its chip shows as missing and blocks Send.
+export const NATIVE_CHAT_ATTACHMENT_TTL_MS = 30 * 24 * 60 * 60 * 1000
+const SWEEP_FIRST_DELAY_MS = 30 * 1000
+const SWEEP_INTERVAL_MS = 60 * 60 * 1000
+
+export function getNativeChatAttachmentRoot(): string {
+  return join(getAppEnvironment().getPath('userData'), ATTACHMENT_ROOT_NAME)
+}
+
+/** Writes one chat attachment under Orca's own storage and returns its path. */
+export async function saveNativeChatAttachmentFile(
+  fileName: string,
+  contents: Buffer
+): Promise<string> {
+  const root = getNativeChatAttachmentRoot()
+  if (!(await ensureNativeChatAttachmentRoot(root))) {
+    throw new Error('Chat attachment storage is not a directory')
+  }
+  const filePath = join(await mkdtemp(join(root, ATTACHMENT_DIR_PREFIX)), fileName)
+  await writeFile(filePath, contents)
+  return filePath
+}
+
+/** The attachment root as a filesystem root, so a restored draft's previews still resolve. */
+export function getNativeChatAttachmentAllowedRoots(): string[] {
+  return hasAppEnvironment() ? [resolve(getNativeChatAttachmentRoot())] : []
+}
+
+/**
+ * The one rule for this folder, for pastes and composer drops alike: Orca creates it owner-only,
+ * and an existing one only has to be a real directory, not a symlink.
+ */
+export async function ensureNativeChatAttachmentRoot(
+  root = getNativeChatAttachmentRoot()
+): Promise<boolean> {
+  await mkdir(root, { recursive: true, mode: 0o700 })
+  return isRealDirectory(root)
+}
+
+// Why not the shared-temp ownership check: user data is already per user, and its modes may not
+// survive a restore or a filesystem without them.
+async function isRealDirectory(path: string): Promise<boolean> {
+  try {
+    return (await lstat(path)).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+export async function sweepExpiredNativeChatAttachments(nowMs = Date.now()): Promise<void> {
+  const root = getNativeChatAttachmentRoot()
+  if (!(await isRealDirectory(root))) {
+    return
+  }
+  await sweepExpiredOwnedDirectories(root, {
+    nowMs,
+    ttlMs: NATIVE_CHAT_ATTACHMENT_TTL_MS,
+    ownsEntry: (name) => ATTACHMENT_DIR_PATTERN.test(name) || DRAG_TEMP_COPY_DIR_PATTERN.test(name)
+  })
+}
+
+let sweepScheduled = false
+
+/** Sweep shortly after startup, then hourly, so a long-running app still expires attachments. */
+export function scheduleNativeChatAttachmentSweep(): void {
+  if (sweepScheduled) {
+    return
+  }
+  sweepScheduled = true
+  const sweep = (): void => {
+    void sweepExpiredNativeChatAttachments().catch(() => undefined)
+  }
+  setTimeout(sweep, SWEEP_FIRST_DELAY_MS).unref()
+  setInterval(sweep, SWEEP_INTERVAL_MS).unref()
+}
diff --git a/src/main/window/native-file-drop-relay.test.ts b/src/main/window/native-file-drop-relay.test.ts
index 276387bc6a4..353e1fcbf27 100644
--- a/src/main/window/native-file-drop-relay.test.ts
+++ b/src/main/window/native-file-drop-relay.test.ts
@@ -36,6 +36,11 @@ vi.mock('./darwin-user-temp-dir', () => ({
   getDarwinUserTempDir: async () => '/private/var/folders/ab/xyz/T'
 }))
 
+vi.mock('./native-chat-attachment-store', () => ({
+  getNativeChatAttachmentRoot: () => '/user-data/native-chat-attachments',
+  ensureNativeChatAttachmentRoot: vi.fn()
+}))
+
 import {
   createNativeFileDropQueue,
   MAX_PENDING_DRAG_TEMP_COPIES,
@@ -473,4 +478,30 @@ describe('registerFileDropRelay', () => {
       expect(webContents.send).not.toHaveBeenCalled()
     }
   )
+
+  // A chat draft can hold the image across a reboot; terminal drops keep their temp copies.
+  it.skipIf(process.platform !== 'darwin')(
+    "copies a composer drop into the chat's attachment storage",
+    async () => {
+      materializeMock.mockResolvedValue([copied(DRAG_TEMP, COPY)])
+      const { window, webContents } = createWindow()
+      registerFileDropRelay(window)
+
+      relay()({ sender: webContents }, { paths: [DRAG_TEMP], target: 'composer' })
+      await settle()
+      relay()({ sender: webContents }, { paths: [DRAG_TEMP], target: 'terminal' })
+      await settle()
+
+      expect(materializeMock.mock.calls.map((call) => call[1].copyRoot)).toEqual([
+        '/user-data/native-chat-attachments',
+        expect.stringContaining('orca-drops')
+      ])
+      // The chat folder has one rule for pastes and drops; the shared temp root keeps its own.
+      const { ensureNativeChatAttachmentRoot } = await import('./native-chat-attachment-store')
+      expect(materializeMock.mock.calls.map((call) => call[1].prepareCopyRoot)).toEqual([
+        ensureNativeChatAttachmentRoot,
+        undefined
+      ])
+    }
+  )
 })
diff --git a/src/main/window/native-file-drop-relay.ts b/src/main/window/native-file-drop-relay.ts
index b8af442e895..9927dd1385e 100644
--- a/src/main/window/native-file-drop-relay.ts
+++ b/src/main/window/native-file-drop-relay.ts
@@ -16,6 +16,10 @@ import {
   type DragTempCopyEnvironment
 } from './dragged-temp-file-copy'
 import { getDarwinUserTempDir } from './darwin-user-temp-dir'
+import {
+  ensureNativeChatAttachmentRoot,
+  getNativeChatAttachmentRoot
+} from './native-chat-attachment-store'
 
 // Why: copies run one at a time, so a hung copy must not hold every later copy forever.
 const DRAG_TEMP_COPY_TIMEOUT_MS = 2 * 60 * 1000
@@ -29,7 +33,9 @@ type RendererLifetime = { signal: AbortSignal; dispose: () => void }
 type NativeFileDropQueueDeps = {
   forward: (payload: NativeFileDropPayload) => void
   platform: NodeJS.Platform
-  getCopyEnvironment: () => Promise<DragTempCopyEnvironment>
+  getCopyEnvironment: (
+    target: AcceptedNativeFileDropPayload['target']
+  ) => Promise<DragTempCopyEnvironment>
   watchRenderer: () => RendererLifetime
   copyTimeoutMs?: number
 }
@@ -47,10 +53,17 @@ export function registerFileDropRelay(mainWindow: BrowserWindow): void {
       }
     },
     platform: process.platform,
-    getCopyEnvironment: async () => ({
+    getCopyEnvironment: async (target) => ({
       platform: process.platform,
       sourceTempRoot: await getDarwinUserTempDir(),
-      copyRoot: getDragTempCopyRoot(app.getPath('temp'))
+      // Why: a chat draft can hold a dropped image across a reboot, so it is kept with pastes,
+      // under the same folder rule.
+      ...(target === NATIVE_FILE_DROP_TARGET.composer
+        ? {
+            copyRoot: getNativeChatAttachmentRoot(),
+            prepareCopyRoot: ensureNativeChatAttachmentRoot
+          }
+        : { copyRoot: getDragTempCopyRoot(app.getPath('temp')) })
     }),
     watchRenderer: () => abortWhenRendererGone(mainWebContents)
   })
@@ -205,7 +218,9 @@ async function copyAndForward(
   try {
     // Why: race the signal too, since a hung fs call never reaches the copy's abort checks.
     prepared = await rejectOnAbort(
-      deps.getCopyEnvironment().then((env) => prepareNativeFileDrop(payload, env, signal)),
+      deps
+        .getCopyEnvironment(payload.target)
+        .then((env) => prepareNativeFileDrop(payload, env, signal)),
       signal
     )
   } catch {
diff --git a/src/preload/api-types.ts b/src/preload/api-types.ts
index 220b90c18a6..67141741d8c 100644
--- a/src/preload/api-types.ts
+++ b/src/preload/api-types.ts
@@ -171,6 +171,7 @@ export type {
   NativeChatApi,
   NativeChatAppendedMessages,
   NativeChatAppendedPayload,
+  NativeChatDraftsApi,
   NativeChatReadSessionResult,
   NativeChatSubscribeArgs,
   NativeChatSubscriptionFrame
diff --git a/src/preload/api/native-chat-api.ts b/src/preload/api/native-chat-api.ts
index 90cb5b0cfba..9f9cc2272ee 100644
--- a/src/preload/api/native-chat-api.ts
+++ b/src/preload/api/native-chat-api.ts
@@ -3,6 +3,11 @@ import type {
   NativeChatMessage,
   NativeChatTurnLifecycle
 } from '../../shared/native-chat-types'
+import type {
+  NativeChatDraftStoreResult,
+  PersistedNativeChatDraft,
+  SavedNativeChatDraft
+} from '../../shared/native-chat-draft-record'
 
 // notFound marks a not-yet-on-disk miss (retry-worthy) vs a real read/parse error (#8401).
 export type NativeChatReadSessionResult =
@@ -71,4 +76,27 @@ export type NativeChatApi = {
     args: NativeChatSubscribeArgs,
     onFrame: (frame: NativeChatSubscriptionFrame) => void
   ) => () => void
+  /** Composer drafts: kept by the main process on desktop, in browser storage in the web client. */
+  drafts: NativeChatDraftsApi
+}
+
+export type NativeChatDraftsApi = {
+  /** Every saved draft, oldest first. */
+  load: () => Promise<SavedNativeChatDraft[]>
+  /** The same, blocking; only for a renderer that needs drafts before `load` returned. */
+  loadSync: () => SavedNativeChatDraft[]
+  /** `null` clears. Resolves once written to the file (no fsync), or once the write failed. */
+  write: (
+    scopeKey: string,
+    draft: PersistedNativeChatDraft | null
+  ) => Promise<NativeChatDraftStoreResult>
+  /**
+   * Save a send's clear at Enter instead of once the host has the message. Browser storage reaches
+   * disk lazily anyway, and clearing first frees the quota the outbox append shares with drafts.
+   */
+  savesSendClearAtOnce?: true
+  /** Another window changed a draft; only where several windows share one draft store. */
+  onExternalChange?: (
+    listener: (scopeKey: string, draft: PersistedNativeChatDraft | null) => void
+  ) => void
 }
diff --git a/src/preload/api/native-chat-bridge.ts b/src/preload/api/native-chat-bridge.ts
index 3a0a5d9161a..e168fdc8308 100644
--- a/src/preload/api/native-chat-bridge.ts
+++ b/src/preload/api/native-chat-bridge.ts
@@ -37,5 +37,10 @@ export const nativeChatApi = {
       ipcRenderer.removeListener('nativeChat:appended', listener)
       ipcRenderer.send('nativeChat:unsubscribe', { subscriptionId: args.subscriptionId })
     }
+  },
+  drafts: {
+    load: () => ipcRenderer.invoke('nativeChat:drafts:load'),
+    loadSync: () => ipcRenderer.sendSync('nativeChat:drafts:loadSync'),
+    write: (scopeKey, draft) => ipcRenderer.invoke('nativeChat:drafts:write', { scopeKey, draft })
   }
 } satisfies PreloadApi['nativeChat']
diff --git a/src/preload/api/ui-bridge-clipboard-and-window-controls.ts b/src/preload/api/ui-bridge-clipboard-and-window-controls.ts
index 51957a5eec5..0e9e5fec519 100644
--- a/src/preload/api/ui-bridge-clipboard-and-window-controls.ts
+++ b/src/preload/api/ui-bridge-clipboard-and-window-controls.ts
@@ -93,6 +93,7 @@ export const uiClipboardAndWindowControlsApi = {
   saveClipboardImageAsTempFile: (args?: {
     connectionId?: string | null
     runtimeEnvironmentId?: string | null
+    chatAttachment?: boolean
   }): Promise<string | null> => ipcRenderer.invoke('clipboard:saveImageAsTempFile', args),
   clipboardHasImage: (): Promise<boolean> => ipcRenderer.invoke('clipboard:hasImage'),
   readClipboardFilePaths: (): Promise<string[]> => ipcRenderer.invoke('clipboard:readFilePaths'),
diff --git a/src/preload/api/ui-window-api.ts b/src/preload/api/ui-window-api.ts
index c36896a2481..71d63022657 100644
--- a/src/preload/api/ui-window-api.ts
+++ b/src/preload/api/ui-window-api.ts
@@ -12,6 +12,8 @@ export type UiWindowApi = {
   saveClipboardImageAsTempFile: (args?: {
     connectionId?: string | null
     runtimeEnvironmentId?: string | null
+    /** Keep a local image in Orca's chat attachment storage instead of OS temp. */
+    chatAttachment?: boolean
   }) => Promise<string | null>
   clipboardHasImage: () => Promise<boolean | null>
   /** Paths of files a file manager copied; empty when there are none or the host cannot list them. */
diff --git a/src/renderer/src/app-shell/use-app-startup-hydration.ts b/src/renderer/src/app-shell/use-app-startup-hydration.ts
index 4186481e7fa..e68256fd2b3 100644
--- a/src/renderer/src/app-shell/use-app-startup-hydration.ts
+++ b/src/renderer/src/app-shell/use-app-startup-hydration.ts
@@ -21,6 +21,7 @@ import {
 import { recoverFromDegradedStartup } from '../startup/startup-degraded-recovery'
 import { restoreSshConnectionsForStartup } from '../startup/startup-ssh-connection-restore'
 import { collectActiveWorkspaceSshTargetIds } from '../startup/active-workspace-ssh-targets'
+import { listRuntimeSessionHostIdsForStartup } from '../startup/startup-runtime-session-hosts'
 import { publishTerminalViewAttributesAtAppStart } from '../components/terminal-pane/terminal-appearance'
 import { getSystemPrefersDark } from '../lib/terminal-theme'
 import {
@@ -30,24 +31,12 @@ import {
 import {
   getRepoExecutionHostId,
   isRuntimeOwnedSshTargetId,
-  parseExecutionHostId,
-  toRuntimeExecutionHostId,
-  type ExecutionHostId
+  parseExecutionHostId
 } from '../../../shared/execution-host'
 import { mapWithConcurrency } from '../../../shared/map-with-concurrency'
 import type { OnboardingState } from '../../../shared/onboarding-state-types'
 import { ensureLocalRuntimeCapabilities } from '../runtime/local-runtime-capabilities'
-
-async function listRuntimeSessionHostIdsForStartup(): Promise<ExecutionHostId[]> {
-  try {
-    return (await window.api.runtimeEnvironments.list()).map((environment) =>
-      toRuntimeExecutionHostId(environment.id)
-    )
-  } catch (err) {
-    console.warn('Failed to list runtime session hosts for startup:', err)
-    return []
-  }
-}
+import { preloadNativeChatDrafts } from '../components/native-chat/native-chat-draft-storage'
 
 /**
  * Runs the renderer's one-shot boot chain: settings, persisted UI, the local repo catalog,
@@ -141,6 +130,10 @@ export function useAppStartupHydration(onOnboardingLoaded: (state: OnboardingSta
             actions.fetchFolderWorkspacesForAllHosts({ remoteHosts: 'skip' })
           )
         })()
+        // Why before the session hydrates: a chat's composer shows its saved draft on first paint.
+        const draftsPromise = timeRendererStartupStep('native-chat-drafts-load', () =>
+          preloadNativeChatDrafts()
+        )
         const sessionReadPromise = runtimeHostsPromise.then((startupRuntimeHostIds) =>
           // Why: include saved runtime host ids so per-host worktree session slices restore from local settings without waiting on network reachability; unreadable partitions skip.
           timeRendererStartupStep('session-get', () =>
@@ -193,6 +186,7 @@ export function useAppStartupHydration(onOnboardingLoaded: (state: OnboardingSta
         await timeRendererStartupStep('repo-catalog-final-settlement', () =>
           actions.awaitLocalRepoCatalogSettlement()
         )
+        await draftsPromise
         if (!cancelled) {
           const sessionHydrationOptions = {
             additionalValidWorkspaceKeys: collectFolderWorkspaceKeysFromSession(sessionRead.session)
diff --git a/src/renderer/src/components/native-chat/NativeChatComposer.test.tsx b/src/renderer/src/components/native-chat/NativeChatComposer.test.tsx
index ad5ad98a62a..53aa23058c4 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposer.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposer.test.tsx
@@ -8,6 +8,7 @@ import type {
 } from '../../../../shared/native-chat-session-options'
 import { clearNativeChatSessionOptionCacheForTests } from './native-chat-session-option-cache'
 import { clearNativeChatModelEnrichmentForTests } from './native-chat-session-option-enrichment'
+import type * as NativeChatDraftCacheModule from './native-chat-draft-cache'
 
 const mocks = vi.hoisted(() => ({
   cancelPendingSends: vi.fn(),
@@ -103,7 +104,8 @@ vi.mock('./use-native-chat-draft', () => ({
     return { draft: mocks.draft, setDraft: mocks.setDraft, flushDraftAppends: () => {} }
   }
 }))
-vi.mock('./native-chat-draft-cache', () => ({
+vi.mock('./native-chat-draft-cache', async (importOriginal) => ({
+  ...(await importOriginal<typeof NativeChatDraftCacheModule>()),
   readNativeChatDraftCache: () => ''
 }))
 vi.mock('./NativeChatComposerField', () => ({
@@ -245,7 +247,7 @@ describe('NativeChatComposer', () => {
     )
   })
 
-  it('associates a delayed submit with its optimistic cache entry', () => {
+  it('associates a delayed submit with its optimistic cache entry', async () => {
     const onOptimisticSend = vi.fn(() => 'pending-1')
     render(
       <NativeChatComposer
@@ -257,7 +259,7 @@ describe('NativeChatComposer', () => {
       />
     )
 
-    act(() => mocks.fieldProps?.onSend?.())
+    await act(async () => mocks.fieldProps?.onSend?.())
 
     expect(onOptimisticSend).toHaveBeenCalledWith('hello', [])
     expect(mocks.trackPendingSend).toHaveBeenCalledWith(mocks.sendHandle, 'pending-1')
@@ -386,7 +388,7 @@ describe('NativeChatComposer', () => {
     expect(mocks.setDraft).toHaveBeenCalledWith('')
   })
 
-  it('disables Send and blocks a send while an image attachment is still pending', () => {
+  it('disables Send and blocks a send while an image attachment is still pending', async () => {
     mocks.imageAttachments = [{ id: 'image-1', path: '', pending: true }]
     render(
       <NativeChatComposer
@@ -399,14 +401,14 @@ describe('NativeChatComposer', () => {
 
     expect(mocks.fieldProps?.sendButtonDisabled).toBe(true)
 
-    act(() => mocks.fieldProps?.onSend?.())
+    await act(async () => mocks.fieldProps?.onSend?.())
 
     expect(mocks.sendNativeChatMessage).not.toHaveBeenCalled()
     expect(mocks.sendNativeChatTypedCommand).not.toHaveBeenCalled()
     expect(mocks.sendNativeChatMessageWithImageAttachments).not.toHaveBeenCalled()
   })
 
-  it('enables Send and dispatches once a pending attachment resolves', () => {
+  it('enables Send and dispatches once a pending attachment resolves', async () => {
     mocks.imageAttachments = [{ id: 'image-1', path: '', pending: true }]
     const view = render(
       <NativeChatComposer
@@ -429,7 +431,7 @@ describe('NativeChatComposer', () => {
     )
     expect(mocks.fieldProps?.sendButtonDisabled).toBe(false)
 
-    act(() => mocks.fieldProps?.onSend?.())
+    await act(async () => mocks.fieldProps?.onSend?.())
 
     expect(mocks.sendNativeChatMessageWithImageAttachments).toHaveBeenCalledWith(
       'codex',
@@ -441,7 +443,7 @@ describe('NativeChatComposer', () => {
     )
   })
 
-  it('types Codex slash composer sends instead of pasting them', () => {
+  it('types Codex slash composer sends instead of pasting them', async () => {
     mocks.draft = '/status'
     render(
       <NativeChatComposer
@@ -452,13 +454,13 @@ describe('NativeChatComposer', () => {
       />
     )
 
-    act(() => mocks.fieldProps?.onSend?.())
+    await act(async () => mocks.fieldProps?.onSend?.())
 
     expect(mocks.sendNativeChatTypedCommand).toHaveBeenCalledWith({}, 'pty-1', '/status')
     expect(mocks.sendNativeChatMessage).not.toHaveBeenCalled()
   })
 
-  it('keeps Codex skill sends pasted', () => {
+  it('keeps Codex skill sends pasted', async () => {
     mocks.draft = '$ref-oss'
     render(
       <NativeChatComposer
@@ -469,13 +471,13 @@ describe('NativeChatComposer', () => {
       />
     )
 
-    act(() => mocks.fieldProps?.onSend?.())
+    await act(async () => mocks.fieldProps?.onSend?.())
 
     expect(mocks.sendNativeChatMessage).toHaveBeenCalledWith({}, 'pty-1', '$ref-oss', undefined)
     expect(mocks.sendNativeChatTypedCommand).not.toHaveBeenCalled()
   })
 
-  it.each(['claude'] as const)('keeps %s slash composer sends pasted', (agent) => {
+  it.each(['claude'] as const)('keeps %s slash composer sends pasted', async (agent) => {
     mocks.draft = '/clear'
     render(
       <NativeChatComposer
@@ -486,13 +488,13 @@ describe('NativeChatComposer', () => {
       />
     )
 
-    act(() => mocks.fieldProps?.onSend?.())
+    await act(async () => mocks.fieldProps?.onSend?.())
 
     expect(mocks.sendNativeChatMessage).toHaveBeenCalledWith({}, 'pty-1', '/clear', undefined)
     expect(mocks.sendNativeChatTypedCommand).not.toHaveBeenCalled()
   })
 
-  it('retires the launch-draft seed once a send clears the TUI input line', () => {
+  it('retires the launch-draft seed once a send clears the TUI input line', async () => {
     render(
       <NativeChatComposer
         terminalTabId="tab-1"
@@ -503,7 +505,7 @@ describe('NativeChatComposer', () => {
     )
     expect(mocks.clearNativeChatLaunchDraft).not.toHaveBeenCalled()
 
-    act(() => mocks.fieldProps?.onSend?.())
+    await act(async () => mocks.fieldProps?.onSend?.())
 
     expect(mocks.clearNativeChatLaunchDraft).toHaveBeenCalledWith('tab-1')
   })
@@ -536,7 +538,7 @@ describe('NativeChatComposer', () => {
       />
     )
 
-    expect(new Set(mocks.draftScopeKeys)).toEqual(new Set(['tab-1:leaf-1']))
+    expect(new Set(mocks.draftScopeKeys)).toEqual(new Set(['pane:tab-1:leaf-1']))
     expect(view.getByTestId('native-chat-composer-field')).toBe(field)
   })
 
diff --git a/src/renderer/src/components/native-chat/NativeChatComposer.tsx b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
index d9fb9f1ec2d..dafa6a68525 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposer.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposer.tsx
@@ -10,6 +10,7 @@ import {
   type HistoryState
 } from './native-chat-composer-state'
 import { useNativeChatDraft } from './use-native-chat-draft'
+import { nativeChatDraftKey } from './native-chat-draft-cache'
 import { useNativeChatLaunchDraftAdoption } from './use-native-chat-launch-draft-adoption'
 import { NativeChatComposerField } from './NativeChatComposerField'
 import type { NativeChatResolvedTarget } from './native-chat-composer-target'
@@ -71,22 +72,21 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
     },
     ref
   ): React.JSX.Element {
-    // Scope key shared with image attachments so an unsent draft + its attached
-    // images survive both TUI/GUI toggles and PTY replacement on reconnect.
-    // Why: local, SSH, and runtime reconnects can replace or temporarily clear
-    // the PTY id. Pane identity is the stable ownership key for unsent input.
+    // The unsent text and images belong to the chat, shared by every view of it; the pane key
+    // stays the identity of this editor and its drop target. Why not the PTY id: local, SSH,
+    // and runtime reconnects can replace or temporarily clear it.
+    const draftKey = nativeChatDraftKey({ sessionId: structuredTransport?.sessionId, paneKey })
     const imeEnterGesture = useImeEnterGestureOwnership()
     const { draft, setDraft, flushDraftAppends } = useNativeChatDraft(
-      paneKey,
+      draftKey,
       imeEnterGesture.isComposing
     )
     const [caret, setCaret] = useState(draft.length)
     useNativeChatLaunchDraftAdoption({
       terminalTabId,
       agent,
-      launchDraft: launchSeed?.launchDraft,
-      launchDraftResolved: launchSeed?.launchDraftResolved === true,
-      ownsTabWideLaunchDraft: launchSeed?.ownsTabWideLaunchDraft === true,
+      launchSeed,
+      tuiDraftKey: structuredTransport ? undefined : draftKey,
       draft,
       setDraft,
       setCaret
@@ -154,7 +154,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
     }, [])
 
     const attachments = useNativeChatComposerAttachments({
-      attachmentScopeKey: paneKey,
+      attachmentScopeKey: draftKey,
       allowWithoutTarget: Boolean(structuredTransport),
       caret,
       disabled,
@@ -182,12 +182,12 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
       attachResolvedPaths,
       setNotice
     })
-    // A pasted image has no agent-readable path until its save lands; sending
-    // mid-save would ship the message without the image the chip promises.
-    const hasPendingAttachment = imageAttachments.some((attachment) => attachment.pending)
+    // A pasted image has no agent-readable path until its save lands, and a missing one never
+    // will; sending would ship the message without the image the chip promises.
+    const hasBlockedAttachment = imageAttachments.some((chip) => chip.pending || chip.missing)
     const sendButtonDisabled = isWorking
       ? !hasPty || !onStop
-      : disabled || hasPendingAttachment || (draft.trim() === '' && imageAttachments.length === 0)
+      : disabled || hasBlockedAttachment || (draft.trim() === '' && imageAttachments.length === 0)
 
     const { attachExternalPaths, resolveAttachmentOwner } = useNativeChatExternalAttachments({
       terminalTabId,
@@ -250,6 +250,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
 
     const sendStructured = useNativeChatStructuredComposerSend({
       agent,
+      draftKey,
       draft,
       imageAttachments,
       structuredTransport,
@@ -262,6 +263,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
 
     const sendPty = useNativeChatPtyComposerSend({
       agent,
+      draftKey,
       draft,
       imageAttachments,
       disabled,
@@ -306,6 +308,7 @@ const NativeChatComposerPane = forwardRef<NativeChatComposerHandle, NativeChatCo
 
     const dispatchPtyPickerCommand = useNativeChatPickerCommandDispatch({
       agent,
+      draftKey,
       disabled,
       isDispatchingSessionOption,
       resolveTarget,
diff --git a/src/renderer/src/components/native-chat/NativeChatComposerField.tsx b/src/renderer/src/components/native-chat/NativeChatComposerField.tsx
index ccbd38afe84..861a1e9f481 100644
--- a/src/renderer/src/components/native-chat/NativeChatComposerField.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatComposerField.tsx
@@ -5,6 +5,7 @@ import { useLayoutEffect, useRef } from 'react'
 import { ImageOff } from 'lucide-react'
 import type { useImeEnterGestureOwnership } from '@/lib/ime-composition-keyboard-event'
 import { cn } from '@/lib/utils'
+import type { NativeChatDraftAttachmentLocation } from './native-chat-draft-storage'
 import { NATIVE_FILE_DROP_TARGET } from '../../../../shared/native-file-drop'
 import type { ComposerAutocomplete, NativeChatPickerItem } from './native-chat-composer-state'
 import { NativeChatMentionHint, NativeChatPickerMenu } from './NativeChatAutocompleteMenus'
@@ -68,11 +69,16 @@ export type NativeChatComposerImageAttachment = {
   /** Empty while `pending`: the clipboard image has no agent-readable path yet. */
   path: string
   connectionId?: string
+  location?: NativeChatDraftAttachmentLocation
   /** Clipboard thumbnail (blob/data URL) rendered before — and after — the file
    *  lands, so the chip never waits on a disk round-trip to show something. */
   previewUrl?: string
   /** True while the pasted image is still being written to disk or uploaded. */
   pending?: boolean
+  /** The file is gone (a restored draft outlived it); Send waits until the chip is removed. */
+  missing?: boolean
+  /** A restored chip being granted and checked; its preview waits so the read is not refused. */
+  checking?: boolean
 }
 
 /**
@@ -221,6 +227,15 @@ export function NativeChatComposerField({
                 ))}
               </div>
             ) : null}
+            {/* Why visible: Send stays disabled while a chip is missing, and a tooltip alone hides the reason. */}
+            {imageAttachments.some((attachment) => attachment.missing) ? (
+              <p className="mb-2 px-1 text-xs text-destructive">
+                {translate(
+                  'components.native-chat.composer.imageMissing',
+                  'Image no longer available. Remove it to send.'
+                )}
+              </p>
+            ) : null}
             <NativeChatPromptEditor
               key={composerScopeKey}
               scopeKey={composerScopeKey}
diff --git a/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.test.tsx b/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.test.tsx
index 2b5924e9826..97fb38e9256 100644
--- a/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.test.tsx
@@ -52,4 +52,16 @@ describe('NativeChatImageAttachmentPreview', () => {
 
     expect(mocks.useLocalImageSrc).toHaveBeenCalledWith(undefined, '', undefined)
   })
+
+  // Read before its grant comes back, a restored image would stay blank.
+  it('reads a restored image only once its check is done', () => {
+    mocks.useLocalImageSrc.mockReturnValue(undefined)
+    renderPreview({ id: 'a1', path: '/Users/me/shot.png', checking: true })
+
+    expect(mocks.useLocalImageSrc).toHaveBeenLastCalledWith(
+      undefined,
+      '/Users/me/shot.png',
+      undefined
+    )
+  })
 })
diff --git a/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.tsx b/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.tsx
index 52e9a5f7c3a..45e3312b84b 100644
--- a/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatImageAttachmentPreview.tsx
@@ -1,9 +1,10 @@
 import { useEffect, useRef, useState } from 'react'
-import { Image as ImageIcon, Loader2, X } from 'lucide-react'
+import { Image as ImageIcon, ImageOff, Loader2, X } from 'lucide-react'
 import { Dialog, DialogContent, DialogDescription, DialogTitle } from '@/components/ui/dialog'
 import { translate } from '@/i18n/i18n'
 import { basename } from '@/lib/path'
 import { useLocalImageSrc } from '@/components/editor/useLocalImageSrc'
+import { cn } from '@/lib/utils'
 import { isNativeChatPastedImagePath } from './native-chat-image-paste'
 import type { NativeChatComposerImageAttachment } from './NativeChatComposerField'
 
@@ -42,8 +43,11 @@ export function NativeChatImageAttachmentPreview({
     return () => observer.disconnect()
   }, [])
   const isPending = attachment.pending === true
+  const isMissing = attachment.missing === true
   const localSrc = useLocalImageSrc(
-    !isPending && (isNearViewport || isOpen) ? attachment.path : undefined,
+    !isPending && !isMissing && !attachment.checking && (isNearViewport || isOpen)
+      ? attachment.path
+      : undefined,
     attachment.path,
     attachment.connectionId
   )
@@ -58,7 +62,11 @@ export function NativeChatImageAttachmentPreview({
     'components.native-chat.composer.imageSaving',
     'Saving pasted image…'
   )
-  const label = isPending ? pendingLabel : filename
+  const missingLabel = `${filename}: ${translate(
+    'components.native-chat.composer.imageMissing',
+    'Image no longer available. Remove it to send.'
+  )}`
+  const label = isPending ? pendingLabel : isMissing ? missingLabel : filename
 
   return (
     <>
@@ -73,9 +81,14 @@ export function NativeChatImageAttachmentPreview({
           aria-busy={isPending}
           title={label}
           onClick={() => setIsOpen(true)}
-          className="flex size-full items-center justify-center overflow-hidden rounded-md border border-border bg-background transition-colors hover:border-ring focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+          className={cn(
+            'flex size-full items-center justify-center overflow-hidden rounded-md border border-border bg-background transition-colors hover:border-ring focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring',
+            isMissing && 'border-destructive'
+          )}
         >
-          {thumbnailSrc ? (
+          {isMissing ? (
+            <ImageOff className="size-5 text-destructive" />
+          ) : thumbnailSrc ? (
             <img
               src={thumbnailSrc}
               alt={label}
@@ -122,6 +135,11 @@ export function NativeChatImageAttachmentPreview({
                     <Loader2 className="size-4 animate-spin" />
                     {pendingLabel}
                   </>
+                ) : isMissing ? (
+                  <>
+                    <ImageOff className="size-4 text-destructive" />
+                    {missingLabel}
+                  </>
                 ) : (
                   <>
                     <ImageIcon className="size-4" />
diff --git a/src/renderer/src/components/native-chat/NativeChatPromptEditor.test.tsx b/src/renderer/src/components/native-chat/NativeChatPromptEditor.test.tsx
index 652086366c0..29969973504 100644
--- a/src/renderer/src/components/native-chat/NativeChatPromptEditor.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatPromptEditor.test.tsx
@@ -1,4 +1,4 @@
-import { readNativeChatDraftDocument } from './native-chat-draft-cache'
+import { readNativeChatDraftDocument } from './native-chat-draft-document-cache'
 // @vitest-environment happy-dom
 import { createRef } from 'react'
 import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
diff --git a/src/renderer/src/components/native-chat/NativeChatPromptEditor.tsx b/src/renderer/src/components/native-chat/NativeChatPromptEditor.tsx
index ceb812e6291..70d45a869aa 100644
--- a/src/renderer/src/components/native-chat/NativeChatPromptEditor.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatPromptEditor.tsx
@@ -1,7 +1,7 @@
 import {
   readNativeChatDraftDocument,
   writeNativeChatDraftDocument
-} from './native-chat-draft-cache'
+} from './native-chat-draft-document-cache'
 import { closeHistory } from '@tiptap/pm/history'
 import { Slice } from '@tiptap/pm/model'
 import {
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
index e2c4c6ff030..8d6fdfc4bac 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test.tsx
@@ -35,7 +35,7 @@ describe('NativeChatStructuredSession', () => {
     resetStructuredSessionMocks()
   })
 
-  it('gives what a Stop withdrew back to the composer this pane shows', () => {
+  it('gives what a Stop withdrew back to the chat draft every pane on it shows', () => {
     render(
       <NativeChatStructuredSession
         isVisible
@@ -48,7 +48,7 @@ describe('NativeChatStructuredSession', () => {
     )
     const paneKey = structuredAgentSessionPaneKey('structured-tab-1', 'session-1')
     expect(mocks.composerProps).toMatchObject({ paneKey })
-    expect(mocks.controllerProps).toMatchObject({ composerScopeKey: paneKey })
+    expect(mocks.controllerProps).toMatchObject({ composerScopeKey: 'session:session-1' })
   })
 
   it('routes the launch draft and app-menu paste to the structured composer', () => {
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index 6b79c8a7fc8..af2fccd3c3e 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -31,6 +31,7 @@ import { structuredAgentSessionReadFailureNotice } from './structured-agent-sess
 import { useStructuredAgentSessionStartFailureFacts } from './use-structured-agent-session-start-failure-facts'
 import { structuredAgentSessionDeliveryNotices } from './structured-agent-session-delivery-notices'
 import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import { nativeChatDraftKey } from './native-chat-draft-cache'
 
 const NO_SUBMISSIONS: readonly AgentJournalSubmission[] = []
 
@@ -53,7 +54,8 @@ export function NativeChatStructuredSession(
   const queueFollowUps = useAppStore((store) => store.settings?.nativeChatQueueFollowUps !== false)
   const controller = useStructuredAgentSession({
     ...props,
-    composerScopeKey: paneKey,
+    composerScopeKey: nativeChatDraftKey({ sessionId: props.sessionId, paneKey }),
+    composerWorktreeId: fileLinkContext?.worktreeId,
     queueFollowUps,
     providerStarting: hostExecution.phase === 'starting',
     transportEnabled: provisionalLaunch.transportEnabled,
diff --git a/src/renderer/src/components/native-chat/native-chat-attachment-existence.ts b/src/renderer/src/components/native-chat/native-chat-attachment-existence.ts
new file mode 100644
index 00000000000..0cdb73316b1
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-attachment-existence.ts
@@ -0,0 +1,55 @@
+import { requirePathExistenceResults } from '../../../../shared/path-existence-batch'
+import type { NativeChatDraftAttachment } from './native-chat-draft-storage'
+
+/**
+ * Ids of attachments whose file is gone. Only a file this machine can ask about is checked: a
+ * local one (granted for reading first, as at attach) or one on an SSH host. One on a runtime
+ * server, or with no recorded location, is never reported; nor is one whose check cannot answer
+ * (an unreachable SSH host, a refused grant): losing contact is not proof the file is gone.
+ */
+export async function findMissingNativeChatAttachments(
+  attachments: readonly NativeChatDraftAttachment[]
+): Promise<Set<string>> {
+  const byConnection = new Map<string, NativeChatDraftAttachment[]>()
+  for (const attachment of attachments) {
+    const connectionId = attachment.connectionId ?? (attachment.location === 'local' ? '' : null)
+    if (connectionId !== null) {
+      byConnection.set(connectionId, [...(byConnection.get(connectionId) ?? []), attachment])
+    }
+  }
+  const missing = new Set<string>()
+  await Promise.all(
+    Array.from(byConnection, async ([connectionId, group]) => {
+      try {
+        const filePaths = group.map((attachment) => attachment.path)
+        if (!connectionId) {
+          // A relaunch forgot the read grant each local image got when it was attached.
+          await Promise.all(filePaths.map(grantRead))
+        }
+        const results = requirePathExistenceResults(
+          await window.api.fs.pathsExist?.({
+            filePaths,
+            ...(connectionId ? { connectionId } : {})
+          }),
+          filePaths.length
+        )
+        results.forEach((result, index) => {
+          if ('exists' in result && !result.exists) {
+            missing.add(group[index].id)
+          }
+        })
+      } catch {
+        // Unverifiable: keep the chip as it is.
+      }
+    })
+  )
+  return missing
+}
+
+async function grantRead(targetPath: string): Promise<void> {
+  try {
+    await window.api.fs.authorizeExternalPath({ targetPath })
+  } catch {
+    // Left ungranted: its preview stays blank and the check below cannot answer for it.
+  }
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx b/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx
index 508a7c20e5e..ffda9656a7e 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-composer-drop-scope.test.tsx
@@ -14,10 +14,10 @@ import { useComposerDropListener } from '../../hooks/composer-state/composer-dro
 import type { NativeFileDropPayload } from '../../../../shared/native-file-drop'
 import { useNativeChatFileAttachmentActions } from './use-native-chat-file-attachment-actions'
 import {
-  clearNativeChatAttachmentCacheForTests,
-  readNativeChatAttachmentCache,
-  useNativeChatComposerAttachments
-} from './use-native-chat-composer-attachments'
+  clearNativeChatDraftCacheForTests,
+  readNativeChatDraftAttachments
+} from './native-chat-draft-cache'
+import { useNativeChatComposerAttachments } from './use-native-chat-composer-attachments'
 
 const electron = vi.hoisted(() => ({
   on: vi.fn(),
@@ -163,7 +163,7 @@ describe('native chat composer drop scoping', () => {
     cleanup()
     resetLocalImageSrcStateForTests()
     vi.unstubAllGlobals()
-    clearNativeChatAttachmentCacheForTests()
+    clearNativeChatDraftCacheForTests()
     electron.send.mockClear()
   })
 
@@ -181,7 +181,7 @@ describe('native chat composer drop scoping', () => {
       reason: 'unresolved-paths',
       target: 'rejected'
     })
-    expect(readNativeChatAttachmentCache('chat-a')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-a')).toEqual([])
   })
 
   it('notices an OS drop whose every path fails authorization', async () => {
@@ -194,7 +194,7 @@ describe('native chat composer drop scoping', () => {
     expect(view.container.querySelector('[data-notice="chat-a"]')?.textContent).toBe(
       "Couldn't read the dropped files."
     )
-    expect(readNativeChatAttachmentCache('chat-a')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-a')).toEqual([])
   })
 
   it('notices an OS drop whose owner changes during authorization', async () => {
@@ -209,7 +209,7 @@ describe('native chat composer drop scoping', () => {
     expect(view.container.querySelector('[data-notice="chat-a"]')?.textContent).toBe(
       'This workspace changed hosts while attaching — drop the files again.'
     )
-    expect(readNativeChatAttachmentCache('chat-a')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-a')).toEqual([])
   })
 
   it('attaches only to the dropped pane and leaves a hidden pane clean on remount', async () => {
@@ -219,8 +219,8 @@ describe('native chat composer drop scoping', () => {
         <ComposerProbe pane="chat-b" hidden />
       </>
     )
-    expect(readNativeChatAttachmentCache('chat-a')).toEqual([])
-    expect(readNativeChatAttachmentCache('chat-b')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-a')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-b')).toEqual([])
 
     const target = view.container.querySelector('[data-pane="chat-a"] .ProseMirror')!
     await dropTwoImages(target)
@@ -230,11 +230,11 @@ describe('native chat composer drop scoping', () => {
       scopeKey: 'chat-a',
       paths: ['/repro/first.png', '/repro/second.png']
     })
-    expect(readNativeChatAttachmentCache('chat-a').map(({ path }) => path)).toEqual([
+    expect(readNativeChatDraftAttachments('chat-a').map(({ path }) => path)).toEqual([
       '/repro/first.png',
       '/repro/second.png'
     ])
-    expect(readNativeChatAttachmentCache('chat-b')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-b')).toEqual([])
     expect(target.textContent).toBe('untouched draft')
 
     view.unmount()
@@ -255,8 +255,8 @@ describe('native chat composer drop scoping', () => {
       target: 'composer',
       paths: ['/repro/first.png', '/repro/second.png']
     })
-    expect(readNativeChatAttachmentCache('chat-a')).toEqual([])
-    expect(readNativeChatAttachmentCache('chat-b')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-a')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-b')).toEqual([])
   })
 
   it('isolates native chat drops from the workspace composer while preserving workspace drops', async () => {
@@ -271,8 +271,8 @@ describe('native chat composer drop scoping', () => {
 
     await dropTwoImages(view.container.querySelector('[data-pane="chat-a"] .ProseMirror')!)
     expect(workspaceDrop).not.toHaveBeenCalled()
-    expect(readNativeChatAttachmentCache('chat-b')).toEqual([])
-    expect(readNativeChatAttachmentCache('chat-a').map(({ path }) => path)).toEqual([
+    expect(readNativeChatDraftAttachments('chat-b')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-a').map(({ path }) => path)).toEqual([
       '/repro/first.png',
       '/repro/second.png'
     ])
@@ -282,11 +282,11 @@ describe('native chat composer drop scoping', () => {
       ['/repro/first.png', '/repro/second.png'],
       expect.any(Function)
     )
-    expect(readNativeChatAttachmentCache('chat-a').map(({ path }) => path)).toEqual([
+    expect(readNativeChatDraftAttachments('chat-a').map(({ path }) => path)).toEqual([
       '/repro/first.png',
       '/repro/second.png'
     ])
-    expect(readNativeChatAttachmentCache('chat-b')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-b')).toEqual([])
   })
 
   it('authorizes only dropped files before preview reads and leaves the other pane untouched', async () => {
@@ -323,8 +323,8 @@ describe('native chat composer drop scoping', () => {
     ])
     expect(intake.readFile).toHaveBeenCalledTimes(2)
     expect(intake.upload).not.toHaveBeenCalled()
-    expect(readNativeChatAttachmentCache('chat-a')).toHaveLength(2)
-    expect(readNativeChatAttachmentCache('chat-b')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-a')).toHaveLength(2)
+    expect(readNativeChatDraftAttachments('chat-b')).toEqual([])
     await expect(intake.readFile({ filePath: '/repro/sibling.png' })).rejects.toThrow(
       'Access denied'
     )
@@ -345,11 +345,11 @@ describe('native chat composer drop scoping', () => {
       intake.owner
     )
     expect(intake.authorizeExternalPath).not.toHaveBeenCalled()
-    expect(readNativeChatAttachmentCache('chat-a').map(({ path }) => path)).toEqual([
+    expect(readNativeChatDraftAttachments('chat-a').map(({ path }) => path)).toEqual([
       '/remote/first.png',
       '/remote/second.png'
     ])
-    expect(readNativeChatAttachmentCache('chat-b')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-b')).toEqual([])
   })
 
   // Mirrors the terminal target, whose leaf id sits inside its drop-target marker.
@@ -382,7 +382,7 @@ describe('native chat composer drop scoping', () => {
       target: 'editor',
       paths: ['/repro/first.png', '/repro/second.png']
     })
-    expect(readNativeChatAttachmentCache('chat-a')).toEqual([])
-    expect(readNativeChatAttachmentCache('chat-b')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-a')).toEqual([])
+    expect(readNativeChatDraftAttachments('chat-b')).toEqual([])
   })
 })
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-scope-cache.ts b/src/renderer/src/components/native-chat/native-chat-composer-scope-cache.ts
index fc26e303a9f..db426dc3922 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-scope-cache.ts
+++ b/src/renderer/src/components/native-chat/native-chat-composer-scope-cache.ts
@@ -1,24 +1,31 @@
-// Shared LRU bound for the native-chat composer's per-scope caches (draft text
-// and image attachments), both keyed by stable pane identity. The
-// caches exist so an in-progress message survives the composer unmounting on a
-// TUI/GUI toggle, but a scope key for a permanently-removed pane is never
-// revisited, so without a bound its unsent entry would linger for the renderer's
-// whole session. delete-then-set keeps the actively-edited scope most-recent so
-// eviction only sheds the oldest untouched scopes.
+// LRU bound for the native-chat composer's per-scope caches. Drafts die with their chat
+// (discardNativeChatDrafts); this bound is the backstop for chats that end where this client
+// never sees it, such as a session closed from another device. delete-then-set keeps the
+// actively-edited scope most-recent so eviction only sheds the oldest untouched scopes.
 export const NATIVE_CHAT_COMPOSER_SCOPE_CACHE_MAX = 128
 
 export function setBoundedScopeCacheEntry<T>(
   cache: Map<string, T>,
   scopeKey: string,
-  value: T
+  value: T,
+  options: {
+    onEvict?: (evictedScopeKey: string) => void
+    /** A scope still in use is never evicted, even past the bound. */
+    inUse?: (scopeKey: string) => boolean
+  } = {}
 ): void {
   cache.delete(scopeKey)
   cache.set(scopeKey, value)
-  while (cache.size > NATIVE_CHAT_COMPOSER_SCOPE_CACHE_MAX) {
-    const oldest = cache.keys().next().value
-    if (oldest === undefined) {
+  let excess = cache.size - NATIVE_CHAT_COMPOSER_SCOPE_CACHE_MAX
+  for (const key of cache.keys()) {
+    if (excess <= 0) {
       break
     }
-    cache.delete(oldest)
+    if (key === scopeKey || options.inUse?.(key)) {
+      continue
+    }
+    cache.delete(key)
+    options.onEvict?.(key)
+    excess -= 1
   }
 }
diff --git a/src/renderer/src/components/native-chat/native-chat-composer-workspace-file-drop.test.tsx b/src/renderer/src/components/native-chat/native-chat-composer-workspace-file-drop.test.tsx
index 898119801ab..0687056f361 100644
--- a/src/renderer/src/components/native-chat/native-chat-composer-workspace-file-drop.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-composer-workspace-file-drop.test.tsx
@@ -14,6 +14,10 @@ import type * as AttachmentUploadModule from './native-chat-attachment-upload'
 import type { NativeChatComposerInput } from './native-chat-composer-input'
 import { NativeChatComposerField } from './NativeChatComposerField'
 import { useNativeChatComposerAttachments } from './use-native-chat-composer-attachments'
+import {
+  clearNativeChatDraftCacheForTests,
+  readNativeChatDraftAttachments
+} from './native-chat-draft-cache'
 import { useNativeChatWorkspaceFileDrop } from './use-native-chat-workspace-file-drop'
 import { useImeEnterGestureOwnership } from '@/lib/ime-composition-keyboard-event'
 
@@ -261,6 +265,7 @@ describe('native chat workspace file drops', () => {
 
   afterEach(() => {
     cleanup()
+    clearNativeChatDraftCacheForTests()
   })
 
   it('consumes a nested editor drop once and inserts top-level paths at the caret', () => {
@@ -371,6 +376,24 @@ describe('native chat workspace file drops', () => {
     expect(screen.getByText('Files can only be attached to their source workspace.')).toBeTruthy()
   })
 
+  // The image lives on the runtime server; after a relaunch this machine cannot check it.
+  it("records that a runtime workspace's dropped image lives on the runtime server", () => {
+    testState.executionHostId = 'runtime:env-1'
+    testState.ownerKind = 'runtime'
+    testState.targetIsRemoteRuntime = true
+    render(<ComposerProbe structured={false} />)
+
+    dispatchDragEvent(
+      'drop',
+      editor(),
+      internalTransfer(['/env/shot.png'], { executionHostId: 'runtime:env-1' })
+    )
+
+    expect(readNativeChatDraftAttachments('pane:worktree-1')).toEqual([
+      { id: expect.any(String), path: '/env/shot.png', location: 'runtime' }
+    ])
+  })
+
   it('queues an internal reference until composition settles without stealing focus', () => {
     render(<ComposerProbe initialDraft="preedit" />)
     const input = editor()
diff --git a/src/renderer/src/components/native-chat/native-chat-draft-cache.test.ts b/src/renderer/src/components/native-chat/native-chat-draft-cache.test.ts
index 7aa0f658517..e1229eafc35 100644
--- a/src/renderer/src/components/native-chat/native-chat-draft-cache.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-draft-cache.test.ts
@@ -16,26 +16,26 @@ describe('native-chat draft cache', () => {
   })
 
   it('round-trips a draft per scope key', () => {
-    writeNativeChatDraftCache('pty-1', 'hello')
-    writeNativeChatDraftCache('pty-2', 'world')
+    writeNativeChatDraftCache('pty-1', 'hello', 'after-pause')
+    writeNativeChatDraftCache('pty-2', 'world', 'after-pause')
     expect(readNativeChatDraftCache('pty-1')).toBe('hello')
     expect(readNativeChatDraftCache('pty-2')).toBe('world')
   })
 
   it('drops the entry when the draft is cleared so stale text never resurfaces', () => {
-    writeNativeChatDraftCache('pty-1', 'hello')
-    writeNativeChatDraftCache('pty-1', '')
+    writeNativeChatDraftCache('pty-1', 'hello', 'after-pause')
+    writeNativeChatDraftCache('pty-1', '', 'now')
     expect(readNativeChatDraftCache('pty-1')).toBe('')
   })
 
   it('bounds the cache so unsent drafts for removed panes cannot accumulate', () => {
-    writeNativeChatDraftCache('keep', 'hot')
+    writeNativeChatDraftCache('keep', 'hot', 'after-pause')
 
     const total = NATIVE_CHAT_COMPOSER_SCOPE_CACHE_MAX + 40
     for (let i = 0; i < total; i += 1) {
-      writeNativeChatDraftCache(`scope-${i}`, `draft-${i}`)
+      writeNativeChatDraftCache(`scope-${i}`, `draft-${i}`, 'after-pause')
       if (i % 20 === 0) {
-        writeNativeChatDraftCache('keep', 'hot')
+        writeNativeChatDraftCache('keep', 'hot', 'after-pause')
       }
     }
 
diff --git a/src/renderer/src/components/native-chat/native-chat-draft-cache.ts b/src/renderer/src/components/native-chat/native-chat-draft-cache.ts
index 333ab7a2c50..f8a6fb656f2 100644
--- a/src/renderer/src/components/native-chat/native-chat-draft-cache.ts
+++ b/src/renderer/src/components/native-chat/native-chat-draft-cache.ts
@@ -1,87 +1,386 @@
-import type { JSONContent } from '@tiptap/react'
-// Module-level cache for the composer's in-progress draft text, keyed by the
-// same stable pane scope as image attachments. The composer unmounts when the
-// pane toggles back to the hosted terminal, so without this the typed-but-unsent
-// draft would be lost on every TUI/GUI round-trip. Mirrors the attachment cache
-// so both halves of an unsent message survive toggles and reconnects.
+// One unsent message (text and image attachments) per chat, shared by every view of that chat and
+// saved to disk (native-chat-draft-storage) so it survives quitting Orca. Views mirror it and
+// subscribe to changes, so typing in one pane shows in every other pane on the same chat.
 
 import { setBoundedScopeCacheEntry } from './native-chat-composer-scope-cache'
+import { createNativeChatDraftSendHolds } from './native-chat-draft-send-holds'
+import { clearNativeChatDraftDocumentsForTests } from './native-chat-draft-document-cache'
+import {
+  clearRestoredNativeChatHeldSendsForTests,
+  forgetRestoredNativeChatHeldSends,
+  noteRestoredNativeChatHeldSends
+} from './native-chat-restored-held-sends'
+import {
+  awaitNativeChatDraftSaved,
+  hasPendingNativeChatDraftPersist,
+  isEmptyNativeChatDraft,
+  nativeChatDraftStoreSavesSendClearAtOnce,
+  loadPersistedNativeChatDrafts,
+  observeOtherWindowNativeChatDrafts,
+  persistNativeChatDraftNow,
+  resetNativeChatDraftStorageForTests,
+  scheduleNativeChatDraftPersist,
+  type NativeChatDraftAttachment,
+  type NativeChatDraftWriteResult,
+  type NativeChatHeldSend,
+  type NativeChatTuiInputSeed,
+  type PersistedNativeChatDraft
+} from './native-chat-draft-storage'
 
-const draftCache = new Map<string, { text: string; document?: JSONContent }>()
+export type { NativeChatDraftAttachment, NativeChatDraftWriteResult, NativeChatTuiInputSeed }
 
-export function readNativeChatDraftCache(scopeKey: string): string {
-  return draftCache.get(scopeKey)?.text ?? ''
+/**
+ * The chat a draft belongs to. A structured chat is its session, whichever pane shows it. A chat
+ * over a terminal agent has no stable session (it changes on `/clear` and on resume), and its
+ * agent lives in exactly one pane, so the pane is the chat.
+ */
+export function nativeChatDraftKey(chat: { sessionId?: string; paneKey: string }): string {
+  return chat.sessionId ? `session:${chat.sessionId}` : `pane:${chat.paneKey}`
 }
 
-export function writeNativeChatDraftCache(scopeKey: string, draft: string): void {
-  // An empty draft carries no state worth retaining; drop the entry so a stale
-  // scope key never resurrects cleared text.
-  if (draft === '') {
-    draftCache.delete(scopeKey)
-    return
+/** A chip in the chat's shared, ordered list; a `pending` one is still being saved and is never written to disk. */
+export type NativeChatDraftChip = NativeChatDraftAttachment & { pending?: true }
+
+type DraftEntry = Omit<PersistedNativeChatDraft, 'attachments'> & {
+  attachments: readonly NativeChatDraftChip[]
+}
+
+const EMPTY_ATTACHMENTS: readonly NativeChatDraftChip[] = []
+const draftCache = new Map<string, DraftEntry>()
+let hydrated = false
+
+let observingOtherWindows = false
+
+function drafts(): Map<string, DraftEntry> {
+  if (!hydrated) {
+    hydrated = true
+    for (const { scopeKey, draft } of loadPersistedNativeChatDrafts()) {
+      draftCache.set(scopeKey, draft)
+      noteRestoredNativeChatHeldSends(scopeKey, draft.heldSends)
+    }
+    if (!observingOtherWindows) {
+      observingOtherWindows = true
+      // A web client tab must not keep showing, and re-save, text another tab already sent.
+      observeOtherWindowNativeChatDrafts((draftKey, draft) => {
+        // This window's pending chips never reach disk, so the other window cannot know them.
+        const pending = readEntry(draftKey).attachments.filter((chip) => chip.pending)
+        const saved = draft ?? { text: '', attachments: EMPTY_ATTACHMENTS }
+        setEntry(draftKey, { ...saved, attachments: [...saved.attachments, ...pending] })
+      })
+    }
+  }
+  return draftCache
+}
+
+function readEntry(draftKey: string): DraftEntry {
+  return drafts().get(draftKey) ?? { text: '', attachments: EMPTY_ATTACHMENTS }
+}
+
+const changeListeners = new Map<string, Set<() => void>>()
+
+function setEntry(draftKey: string, entry: DraftEntry): void {
+  // An empty draft carries no state worth retaining; drop it so a stale key never resurrects it.
+  if (isEmptyNativeChatDraft(entry)) {
+    drafts().delete(draftKey)
+  } else {
+    setBoundedScopeCacheEntry(drafts(), draftKey, entry, {
+      onEvict: (evicted) => void persistNativeChatDraftNow(evicted, null),
+      inUse: (key) => changeListeners.has(key)
+    })
+  }
+  changeListeners.get(draftKey)?.forEach((listener) => listener())
+}
+
+/**
+ * Deletes the drafts of chats that ended, from memory and disk: a closed structured session,
+ * a closed terminal pane, or every pane of a closed terminal tab. None of them comes back
+ * (session ids, tab ids and pane leaf ids are never reused), so nothing could show the draft.
+ */
+export function discardNativeChatDrafts(ended: {
+  sessionIds?: Iterable<string>
+  paneKeys?: Iterable<string>
+  terminalTabIds?: Iterable<string>
+}): void {
+  const doomed = new Set([
+    ...Array.from(ended.sessionIds ?? [], (sessionId) =>
+      nativeChatDraftKey({ sessionId, paneKey: '' })
+    ),
+    ...Array.from(ended.paneKeys ?? [], (paneKey) => nativeChatDraftKey({ paneKey }))
+  ])
+  const tabPrefixes = Array.from(ended.terminalTabIds ?? [], (tabId) =>
+    nativeChatDraftKey({ paneKey: `${tabId}:` })
+  )
+  if (tabPrefixes.length > 0) {
+    for (const draftKey of drafts().keys()) {
+      if (tabPrefixes.some((prefix) => draftKey.startsWith(prefix))) {
+        doomed.add(draftKey)
+      }
+    }
+  }
+  sendHolds.forget(doomed)
+  forgetRestoredNativeChatHeldSends(doomed)
+  for (const draftKey of doomed) {
+    if (drafts().has(draftKey)) {
+      setEntry(draftKey, { text: '', attachments: EMPTY_ATTACHMENTS })
+    }
+    void persistNativeChatDraftNow(draftKey, null)
+  }
+}
+
+function persistedDraft(draftKey: string): PersistedNativeChatDraft | null {
+  const entry = drafts().get(draftKey)
+  return entry
+    ? {
+        ...entry,
+        attachments: entry.attachments.flatMap(({ pending, ...attachment }) =>
+          pending ? [] : [attachment]
+        )
+      }
+    : null
+}
+
+const sendHolds = createNativeChatDraftSendHolds((draftKey) => void persistNow(draftKey))
+
+function persistNow(draftKey: string): Promise<NativeChatDraftWriteResult> {
+  if (sendHolds.isClearingForSend(draftKey)) {
+    return Promise.resolve('memory-only')
   }
-  // LRU-bounded so unsent drafts for permanently-removed panes can't accumulate.
-  setBoundedScopeCacheEntry(draftCache, scopeKey, {
-    text: draft,
-    document:
-      draftCache.get(scopeKey)?.text === draft ? draftCache.get(scopeKey)?.document : undefined
+  return persistNativeChatDraftNow(draftKey, persistedDraft(draftKey))
+}
+
+/**
+ * Empties the chat's box for a send to a terminal agent (`clear`) without saving that, so a crash
+ * before the terminal has the message restores it unsent. Returns `save`: call it once the terminal
+ * has the message, or once the message is back in the box; a message that stays undelivered never
+ * calls it. It saves the draft as it is then, keeping whatever was typed since Enter, unless a later
+ * send on the chat is still waiting. A store that saves a send's clear at once (the web client's
+ * browser storage) saves it now instead. Structured sends keep a held send instead
+ * (`clearNativeChatDraftForHeldSend`).
+ */
+export function clearNativeChatDraftForSend(draftKey: string, clear: () => void): () => void {
+  // The message typed just before Enter may still be waiting for its pause; it is what is saved.
+  if (hasPendingNativeChatDraftPersist(draftKey)) {
+    void persistNow(draftKey)
+  }
+  return sendHolds.clearForSend(draftKey, clear, {
+    saveAtOnce: nativeChatDraftStoreSavesSendClearAtOnce()
   })
 }
 
+/**
+ * Empties the chat's box for a structured send without saving that: the box is saved with the
+ * send's held copy (`updateNativeChatDraftHeldSends`) once the send has its id. A store that saves
+ * a send's clear at once (the web client's browser storage) saves it now and holds no copy.
+ */
+export function clearNativeChatDraftForHeldSend(draftKey: string, clear: () => void): void {
+  if (nativeChatDraftStoreSavesSendClearAtOnce()) {
+    clear()
+    return
+  }
+  // The message typed just before Enter may still be waiting for its pause; it is saved first.
+  if (hasPendingNativeChatDraftPersist(draftKey)) {
+    void persistNow(draftKey)
+  }
+  sendHolds.clearUnsaved(draftKey, clear)
+}
+
+/** Saves the chat's draft as it is now. */
+export function saveNativeChatDraftNow(draftKey: string): Promise<NativeChatDraftWriteResult> {
+  return persistNow(draftKey)
+}
+
+export function readNativeChatDraftHeldSends(draftKey: string): readonly NativeChatHeldSend[] {
+  return readEntry(draftKey).heldSends ?? []
+}
+
+/** Changes the chat's held sends, leaving the live draft as it is; saved at once unless `save` is false. */
+export function updateNativeChatDraftHeldSends(
+  draftKey: string,
+  update: (heldSends: readonly NativeChatHeldSend[]) => readonly NativeChatHeldSend[],
+  options: { save: boolean } = { save: true }
+): void {
+  const { heldSends: previous, ...entry } = readEntry(draftKey)
+  const heldSends = update(previous ?? [])
+  setEntry(draftKey, heldSends.length > 0 ? { ...entry, heldSends } : entry)
+  if (options.save) {
+    void persistNow(draftKey)
+  }
+}
+
+export function readNativeChatDraftCache(draftKey: string): string {
+  return readEntry(draftKey).text
+}
+
+/** Typing waits for a pause; a clear is written at once (a send's, with its held send or, for a
+ *  terminal agent, once the terminal has it). */
+export function writeNativeChatDraftCache(
+  draftKey: string,
+  draft: string,
+  persist: 'now' | 'after-pause'
+): void {
+  setEntry(draftKey, { ...readEntry(draftKey), text: draft })
+  if (persist === 'now') {
+    void persistNow(draftKey)
+  } else {
+    scheduleNativeChatDraftPersist(draftKey, persistedDraft(draftKey))
+  }
+}
+
+/** Waits (briefly) until the chat's last write is saved. */
+export function awaitNativeChatDraftWritten(draftKey: string): Promise<void> {
+  return awaitNativeChatDraftSaved(draftKey)
+}
+
+export function readNativeChatDraftTuiInputSeed(
+  draftKey: string
+): NativeChatTuiInputSeed | undefined {
+  return readEntry(draftKey).tuiInputSeed
+}
+
+/** What Orca typed into the chat's terminal input line, kept with the draft; written at once. */
+export function writeNativeChatDraftTuiInputSeed(
+  draftKey: string,
+  seed: NativeChatTuiInputSeed
+): void {
+  setEntry(draftKey, { ...readEntry(draftKey), tuiInputSeed: seed })
+  void persistNow(draftKey)
+}
+
+/** The tab's launch draft is gone (sent, resolved, closed), so no pane's input line holds it. */
+export function forgetNativeChatTuiInputSeeds(terminalTabId: string): void {
+  const prefix = nativeChatDraftKey({ paneKey: `${terminalTabId}:` })
+  for (const [draftKey, entry] of Array.from(drafts())) {
+    if (draftKey.startsWith(prefix) && entry.tuiInputSeed) {
+      const { tuiInputSeed: _gone, ...rest } = entry
+      setEntry(draftKey, rest)
+      void persistNow(draftKey)
+    }
+  }
+}
+
+export function readNativeChatDraftAttachments(draftKey: string): readonly NativeChatDraftChip[] {
+  return readEntry(draftKey).attachments
+}
+
+// Every view of the chat edits one ordered list, by chip id, and the result is written at once.
+function updateNativeChatDraftAttachments(
+  draftKey: string,
+  update: (chips: readonly NativeChatDraftChip[]) => readonly NativeChatDraftChip[]
+): void {
+  const current = readEntry(draftKey)
+  setEntry(draftKey, { ...current, attachments: update(current.attachments) })
+  void persistNow(draftKey)
+}
+
+export function addNativeChatDraftAttachments(
+  draftKey: string,
+  chips: readonly NativeChatDraftChip[]
+): void {
+  updateNativeChatDraftAttachments(draftKey, (current) => [...current, ...chips])
+}
+
+export function removeNativeChatDraftAttachment(draftKey: string, id: string): void {
+  updateNativeChatDraftAttachments(draftKey, (current) => current.filter((chip) => chip.id !== id))
+}
+
+/** A pending chip's save landed; one removed meanwhile stays removed. */
+export function settleNativeChatDraftAttachment(
+  draftKey: string,
+  settled: NativeChatDraftAttachment
+): void {
+  updateNativeChatDraftAttachments(draftKey, (current) =>
+    current.map((chip) => (chip.id === settled.id ? settled : chip))
+  )
+}
+
+export function clearNativeChatDraftAttachments(draftKey: string): void {
+  updateNativeChatDraftAttachments(draftKey, () => EMPTY_ATTACHMENTS)
+}
+
+/** Fires on every change to the chat's draft. */
+export function subscribeToNativeChatDraft(draftKey: string, listener: () => void): () => void {
+  return subscribe(changeListeners, draftKey, listener)
+}
+
 export function appendNativeChatDraftText(draft: string, text: string): string {
   return draft === '' ? text : `${draft.trimEnd()}\n\n${text}`
 }
 
-// Only a write from outside the composer notifies; its own writes already hold the text.
-const appendListeners = new Map<string, Set<(text: string) => void>>()
+// A composing view cannot show appended text until its IME settles, so it is told what was added.
+const textAppendListeners = new Map<string, Set<(text: string) => void>>()
 
-/** Puts text back after whatever is typed, and tells a mounted composer to show it. */
-export function appendNativeChatDraftCache(scopeKey: string, text: string): void {
-  if (text === '') {
-    return
+export type NativeChatDraftContent = {
+  text: string
+  attachments?: readonly NativeChatDraftAttachment[]
+}
+
+/**
+ * Puts content back after whatever is in the chat's draft, writes it to disk at once, and shows it
+ * in every view of the chat. The result says whether it reached disk.
+ */
+export function appendNativeChatDraftNow(
+  draftKey: string,
+  content: NativeChatDraftContent
+): Promise<NativeChatDraftWriteResult> {
+  const attachments = content.attachments ?? []
+  const current = readEntry(draftKey)
+  if (content.text !== '') {
+    textAppendListeners.get(draftKey)?.forEach((listener) => listener(content.text))
   }
-  writeNativeChatDraftCache(
-    scopeKey,
-    appendNativeChatDraftText(readNativeChatDraftCache(scopeKey), text)
-  )
-  appendListeners.get(scopeKey)?.forEach((listener) => listener(text))
+  setEntry(draftKey, {
+    ...current,
+    text:
+      content.text === '' ? current.text : appendNativeChatDraftText(current.text, content.text),
+    attachments: [...current.attachments, ...attachments]
+  })
+  return persistNow(draftKey)
 }
 
-export function subscribeToNativeChatDraftAppend(
-  scopeKey: string,
-  listener: (text: string) => void
+/** Puts content back only into an empty draft, so nothing the user typed since is touched. */
+export async function restoreNativeChatDraftIfEmpty(
+  draftKey: string,
+  content: NativeChatDraftContent
+): Promise<NativeChatDraftWriteResult | 'composer-not-empty'> {
+  const current = readEntry(draftKey)
+  if (current.text !== '' || current.attachments.length > 0) {
+    return 'composer-not-empty'
+  }
+  return appendNativeChatDraftNow(draftKey, content)
+}
+
+function subscribe<T>(
+  listenersByKey: Map<string, Set<(value: T) => void>>,
+  key: string,
+  listener: (value: T) => void
 ): () => void {
-  const listeners = appendListeners.get(scopeKey) ?? new Set()
-  appendListeners.set(scopeKey, listeners)
+  const listeners = listenersByKey.get(key) ?? new Set()
+  listenersByKey.set(key, listeners)
   listeners.add(listener)
   return () => {
     listeners.delete(listener)
-    if (listeners.size === 0 && appendListeners.get(scopeKey) === listeners) {
-      appendListeners.delete(scopeKey)
+    if (listeners.size === 0 && listenersByKey.get(key) === listeners) {
+      listenersByKey.delete(key)
     }
   }
 }
 
-export function clearNativeChatDraftCacheForTests(): void {
-  draftCache.clear()
+export function subscribeToNativeChatDraftAppend(
+  draftKey: string,
+  listener: (text: string) => void
+): () => void {
+  return subscribe(textAppendListeners, draftKey, listener)
 }
 
-export function readNativeChatDraftDocument(
-  scopeKey: string,
-  text: string
-): JSONContent | undefined {
-  const cached = draftCache.get(scopeKey)
-  return cached?.text === text ? cached.document : undefined
+/** Clears memory and the saved drafts on disk. */
+export function nativeChatSendsAwaitingHostForTests(draftKey: string): number {
+  return sendHolds.sendsAwaitingForTests(draftKey)
 }
 
-export function writeNativeChatDraftDocument(
-  scopeKey: string,
-  text: string,
-  document: JSONContent
-): void {
-  if (!text) {
-    draftCache.delete(scopeKey)
-    return
-  }
-  setBoundedScopeCacheEntry(draftCache, scopeKey, { text, document })
+export function clearNativeChatDraftCacheForTests(): void {
+  sendHolds.clearForTests()
+  clearRestoredNativeChatHeldSendsForTests()
+  draftCache.clear()
+  clearNativeChatDraftDocumentsForTests()
+  hydrated = false
+  resetNativeChatDraftStorageForTests()
 }
diff --git a/src/renderer/src/components/native-chat/native-chat-draft-document-cache.ts b/src/renderer/src/components/native-chat/native-chat-draft-document-cache.ts
new file mode 100644
index 00000000000..ef47db5bdb6
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-draft-document-cache.ts
@@ -0,0 +1,29 @@
+import type { JSONContent } from '@tiptap/react'
+import { setBoundedScopeCacheEntry } from './native-chat-composer-scope-cache'
+
+// Rich editor state belongs to the pane's editor, not the chat; memory only.
+const documentCache = new Map<string, { text: string; document: JSONContent }>()
+
+export function readNativeChatDraftDocument(
+  paneKey: string,
+  text: string
+): JSONContent | undefined {
+  const cached = documentCache.get(paneKey)
+  return cached?.text === text ? cached.document : undefined
+}
+
+export function writeNativeChatDraftDocument(
+  paneKey: string,
+  text: string,
+  document: JSONContent
+): void {
+  if (!text) {
+    documentCache.delete(paneKey)
+    return
+  }
+  setBoundedScopeCacheEntry(documentCache, paneKey, { text, document })
+}
+
+export function clearNativeChatDraftDocumentsForTests(): void {
+  documentCache.clear()
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-draft-persistence.test.ts b/src/renderer/src/components/native-chat/native-chat-draft-persistence.test.ts
new file mode 100644
index 00000000000..42cc653a97f
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-draft-persistence.test.ts
@@ -0,0 +1,451 @@
+// A half-typed chat message survives quitting Orca. Typing is saved after a pause; the clear at
+// send and any text put back are saved at once, so a crash right after Enter cannot bring back
+// text the host already took.
+
+// @vitest-environment happy-dom
+
+import { act, cleanup, renderHook } from '@testing-library/react'
+import { useLayoutEffect } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { NATIVE_CHAT_COMPOSER_SCOPE_CACHE_MAX } from './native-chat-composer-scope-cache'
+import type * as NativeChatDraftCache from './native-chat-draft-cache'
+import {
+  installHeldNativeChatDrafts,
+  installLocalStorageNativeChatDrafts
+} from './native-chat-draft-store.test-support'
+
+const PREFIX = 'orca:nativeChatComposerDraft:v1:'
+const SCOPE = 'structured-agent-session-s1:pane'
+
+type DraftCache = typeof NativeChatDraftCache
+
+/** A fresh renderer: module memory is gone, only localStorage remains. */
+async function relaunch(): Promise<DraftCache> {
+  vi.resetModules()
+  return import('./native-chat-draft-cache')
+}
+
+function saved(scopeKey: string): { text: string; attachments: unknown[] } | null {
+  const raw = localStorage.getItem(`${PREFIX}${encodeURIComponent(scopeKey)}`)
+  return raw ? JSON.parse(raw) : null
+}
+
+let cache: DraftCache
+
+beforeEach(async () => {
+  vi.useFakeTimers()
+  localStorage.clear()
+  installLocalStorageNativeChatDrafts()
+  cache = await relaunch()
+})
+
+afterEach(() => {
+  cleanup()
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+  cache.clearNativeChatDraftCacheForTests()
+  vi.useRealTimers()
+})
+
+/** Storage that reads fine but refuses every write, as a full quota does. */
+function fullStorage(): Storage {
+  const real = localStorage
+  return {
+    get length() {
+      return real.length
+    },
+    key: (index) => real.key(index),
+    getItem: (key) => real.getItem(key),
+    clear: () => real.clear(),
+    removeItem: () => {
+      throw new DOMException('quota', 'QuotaExceededError')
+    },
+    setItem: () => {
+      throw new DOMException('quota', 'QuotaExceededError')
+    }
+  }
+}
+
+describe('composer draft persistence', () => {
+  it('restores typed text and attachments after a relaunch', async () => {
+    cache.writeNativeChatDraftCache(SCOPE, 'half typed', 'after-pause')
+    cache.addNativeChatDraftAttachments(SCOPE, [
+      { id: 'a1', path: '/tmp/shot.png', connectionId: 'ssh-1' }
+    ])
+    vi.advanceTimersByTime(300)
+
+    const next = await relaunch()
+
+    expect(next.readNativeChatDraftCache(SCOPE)).toBe('half typed')
+    expect(next.readNativeChatDraftAttachments(SCOPE)).toEqual([
+      { id: 'a1', path: '/tmp/shot.png', connectionId: 'ssh-1' }
+    ])
+  })
+
+  // Chips saved before their location was recorded must still load, as unknown.
+  it("restores each image chip's location, and loads a chip saved without one", async () => {
+    localStorage.setItem(
+      `${PREFIX}${encodeURIComponent(SCOPE)}`,
+      JSON.stringify({
+        text: '',
+        attachments: [
+          { id: 'old', path: '/old.png' },
+          { id: 'runtime', path: '/srv/a.png', location: 'runtime' },
+          { id: 'odd', path: '/odd.png', location: 'mars' }
+        ]
+      })
+    )
+
+    const next = await relaunch()
+
+    expect(next.readNativeChatDraftAttachments(SCOPE)).toEqual([
+      { id: 'old', path: '/old.png' },
+      { id: 'runtime', path: '/srv/a.png', location: 'runtime' },
+      { id: 'odd', path: '/odd.png' }
+    ])
+  })
+
+  it('saves typing only after the pause', () => {
+    cache.writeNativeChatDraftCache(SCOPE, 'h', 'after-pause')
+    cache.writeNativeChatDraftCache(SCOPE, 'he', 'after-pause')
+    expect(saved(SCOPE)).toBeNull()
+
+    vi.advanceTimersByTime(299)
+    expect(saved(SCOPE)).toBeNull()
+    vi.advanceTimersByTime(1)
+    expect(saved(SCOPE)?.text).toBe('he')
+  })
+
+  it.each([
+    ['beforeunload', () => window.dispatchEvent(new Event('beforeunload'))],
+    ['pagehide', () => window.dispatchEvent(new Event('pagehide'))],
+    [
+      'the page becoming hidden',
+      () => {
+        vi.spyOn(document, 'visibilityState', 'get').mockReturnValue('hidden')
+        document.dispatchEvent(new Event('visibilitychange'))
+      }
+    ]
+  ])('flushes pending typing on %s', (_case, hide) => {
+    cache.writeNativeChatDraftCache(SCOPE, 'about to quit', 'after-pause')
+    expect(saved(SCOPE)).toBeNull()
+
+    hide()
+
+    expect(saved(SCOPE)?.text).toBe('about to quit')
+  })
+
+  it('writes the clear at send at once, cancelling the pending typing write', async () => {
+    cache.writeNativeChatDraftCache(SCOPE, 'sent text', 'after-pause')
+    vi.advanceTimersByTime(300)
+    cache.writeNativeChatDraftCache(SCOPE, 'sent text, edited', 'after-pause')
+
+    // Enter: the composer clears; a crash follows before any timer runs.
+    cache.writeNativeChatDraftCache(SCOPE, '', 'now')
+
+    expect(saved(SCOPE)).toBeNull()
+    const next = await relaunch()
+    expect(next.readNativeChatDraftCache(SCOPE)).toBe('')
+  })
+
+  // The put-back is not the sent text; a crash before the typing delay must not restore the latter.
+  it('writes a clear at once when a put-back made mid-composition rides along', async () => {
+    const { useNativeChatDraft } = await import('./use-native-chat-draft')
+    cache.writeNativeChatDraftCache(SCOPE, 'sent text', 'after-pause')
+    vi.advanceTimersByTime(300)
+    const { result } = renderHook(() => useNativeChatDraft(SCOPE, () => true))
+    act(() => {
+      cache.appendNativeChatDraftNow(SCOPE, { text: 'withdrawn' })
+    })
+
+    act(() => result.current.setDraft(''))
+
+    expect(saved(SCOPE)?.text).toBe('withdrawn')
+  })
+
+  it("shows a write that lands between a view's render and its subscription", async () => {
+    const { useNativeChatDraft } = await import('./use-native-chat-draft')
+    const { result } = renderHook(() => {
+      const view = useNativeChatDraft(SCOPE, () => false)
+      useLayoutEffect(
+        () => cache.writeNativeChatDraftCache(SCOPE, 'written meanwhile', 'after-pause'),
+        []
+      )
+      return view
+    })
+
+    expect(result.current.draft).toBe('written meanwhile')
+  })
+
+  it("forgets a closed tab's input-line seeds, on disk too, and keeps other tabs'", async () => {
+    const seed = { agent: 'claude' as const, text: 'issue link', createdAt: 1 }
+    cache.writeNativeChatDraftTuiInputSeed('pane:tab-1:a', seed)
+    cache.writeNativeChatDraftTuiInputSeed('pane:tab-2:a', seed)
+
+    cache.forgetNativeChatTuiInputSeeds('tab-1')
+
+    const next = await relaunch()
+    expect(next.readNativeChatDraftTuiInputSeed('pane:tab-1:a')).toBeUndefined()
+    expect(next.readNativeChatDraftTuiInputSeed('pane:tab-2:a')).toEqual(seed)
+  })
+
+  it('writes text put back at once and reports that it reached disk', async () => {
+    const result = cache.appendNativeChatDraftNow(SCOPE, {
+      text: 'withdrawn',
+      attachments: [{ id: 'w1', path: '/tmp/w.png' }]
+    })
+
+    await expect(result).resolves.toBe('persisted')
+    expect(saved(SCOPE)).toMatchObject({
+      text: 'withdrawn',
+      attachments: [{ id: 'w1', path: '/tmp/w.png' }]
+    })
+    const next = await relaunch()
+    expect(next.readNativeChatDraftCache(SCOPE)).toBe('withdrawn')
+  })
+
+  it('restores only into an empty composer', async () => {
+    cache.writeNativeChatDraftCache(SCOPE, 'typed since', 'after-pause')
+
+    await expect(cache.restoreNativeChatDraftIfEmpty(SCOPE, { text: 'refused' })).resolves.toBe(
+      'composer-not-empty'
+    )
+    expect(cache.readNativeChatDraftCache(SCOPE)).toBe('typed since')
+
+    cache.writeNativeChatDraftCache(SCOPE, '', 'now')
+    await expect(cache.restoreNativeChatDraftIfEmpty(SCOPE, { text: 'refused' })).resolves.toBe(
+      'persisted'
+    )
+    expect(saved(SCOPE)?.text).toBe('refused')
+  })
+
+  it('keeps drafts for every chat apart', async () => {
+    cache.appendNativeChatDraftNow('chat-a', { text: 'for a' })
+    cache.appendNativeChatDraftNow('chat-b', { text: 'for b' })
+
+    const next = await relaunch()
+
+    expect(next.readNativeChatDraftCache('chat-a')).toBe('for a')
+    expect(next.readNativeChatDraftCache('chat-b')).toBe('for b')
+  })
+
+  it('names a structured chat by its session, whichever pane shows it', async () => {
+    const before = cache.nativeChatDraftKey({ sessionId: 's1', paneKey: 'tab-1:leaf-1' })
+    cache.appendNativeChatDraftNow(before, { text: 'follows the chat' })
+
+    const next = await relaunch()
+    const after = next.nativeChatDraftKey({ sessionId: 's1', paneKey: 'tab-9:leaf-9' })
+
+    expect(next.readNativeChatDraftCache(after)).toBe('follows the chat')
+    expect(next.nativeChatDraftKey({ paneKey: 'tab-1:leaf-1' })).not.toBe(before)
+  })
+
+  it('keeps the draft in memory and reports memory-only when storage throws', async () => {
+    vi.stubGlobal('localStorage', fullStorage())
+
+    expect(() => cache.writeNativeChatDraftCache(SCOPE, 'typed', 'after-pause')).not.toThrow()
+    expect(() => vi.advanceTimersByTime(300)).not.toThrow()
+    await expect(cache.appendNativeChatDraftNow(SCOPE, { text: 'back' })).resolves.toBe(
+      'memory-only'
+    )
+    expect(cache.readNativeChatDraftCache(SCOPE)).toBe('typed\n\nback')
+  })
+
+  it('works without storage at all', async () => {
+    vi.stubGlobal('localStorage', undefined)
+    const next = await relaunch()
+
+    next.writeNativeChatDraftCache(SCOPE, 'typed', 'after-pause')
+    await expect(next.appendNativeChatDraftNow(SCOPE, { text: 'back' })).resolves.toBe(
+      'memory-only'
+    )
+    expect(next.readNativeChatDraftCache(SCOPE)).toBe('typed\n\nback')
+  })
+
+  it('bounds the saved drafts, dropping the least recently written', async () => {
+    const total = NATIVE_CHAT_COMPOSER_SCOPE_CACHE_MAX + 5
+    for (let index = 0; index < total; index += 1) {
+      vi.setSystemTime(1_000 + index)
+      cache.appendNativeChatDraftNow(`scope-${index}`, { text: `draft-${index}` })
+    }
+
+    expect(saved('scope-0')).toBeNull()
+    expect(saved(`scope-${total - 1}`)?.text).toBe(`draft-${total - 1}`)
+    const next = await relaunch()
+    expect(next.readNativeChatDraftCache('scope-4')).toBe('')
+    expect(next.readNativeChatDraftCache('scope-5')).toBe('draft-5')
+  })
+
+  it('prunes saved drafts past the bound when they load', async () => {
+    const total = NATIVE_CHAT_COMPOSER_SCOPE_CACHE_MAX + 3
+    for (let index = 0; index < total; index += 1) {
+      localStorage.setItem(
+        `${PREFIX}scope-${index}`,
+        JSON.stringify({ text: `draft-${index}`, attachments: [], savedAt: index })
+      )
+    }
+    localStorage.setItem(`${PREFIX}broken`, '{not json')
+
+    const next = await relaunch()
+
+    expect(next.readNativeChatDraftCache('scope-2')).toBe('')
+    expect(next.readNativeChatDraftCache('scope-3')).toBe('draft-3')
+    expect(saved('scope-0')).toBeNull()
+    expect(localStorage.getItem(`${PREFIX}broken`)).toBeNull()
+  })
+
+  it('never drops a draft a view is showing, however many newer drafts are written', () => {
+    cache.appendNativeChatDraftNow('open-chat', { text: 'still open' })
+    const unsubscribe = cache.subscribeToNativeChatDraft('open-chat', () => {})
+    for (let index = 0; index < NATIVE_CHAT_COMPOSER_SCOPE_CACHE_MAX + 5; index += 1) {
+      cache.appendNativeChatDraftNow(`scope-${index}`, { text: `draft-${index}` })
+    }
+
+    expect(cache.readNativeChatDraftCache('open-chat')).toBe('still open')
+    expect(saved('open-chat')?.text).toBe('still open')
+    expect(saved('scope-0')).toBeNull()
+    unsubscribe()
+  })
+})
+
+describe('a draft dies with its chat', () => {
+  const chats = {
+    session: { sessionId: 's1', paneKey: 'tab-1:leaf-1' },
+    pane: { paneKey: 'tab-2:leaf-a' },
+    otherPane: { paneKey: 'tab-2:leaf-b' },
+    otherTab: { paneKey: 'tab-22:leaf-a' }
+  }
+
+  beforeEach(() => {
+    for (const chat of Object.values(chats)) {
+      cache.appendNativeChatDraftNow(cache.nativeChatDraftKey(chat), {
+        text: 'unsent',
+        attachments: [{ id: 'i1', path: '/tmp/i.png' }]
+      })
+    }
+  })
+
+  it('deletes a closed session or pane draft, in memory and on disk', async () => {
+    const shown = vi.fn()
+    cache.subscribeToNativeChatDraft(cache.nativeChatDraftKey(chats.session), shown)
+
+    cache.discardNativeChatDrafts({ sessionIds: ['s1'], paneKeys: ['tab-2:leaf-a'] })
+
+    expect(shown).toHaveBeenCalled()
+    expect(cache.readNativeChatDraftCache(cache.nativeChatDraftKey(chats.session))).toBe('')
+    expect(saved(cache.nativeChatDraftKey(chats.pane))).toBeNull()
+    const next = await relaunch()
+    expect(next.readNativeChatDraftCache(next.nativeChatDraftKey(chats.session))).toBe('')
+    expect(next.readNativeChatDraftAttachments(next.nativeChatDraftKey(chats.pane))).toEqual([])
+    expect(next.readNativeChatDraftCache(next.nativeChatDraftKey(chats.otherPane))).toBe('unsent')
+  })
+
+  it('forgets the sends of a chat that ended', () => {
+    const key = cache.nativeChatDraftKey({ sessionId: 's-ended', paneKey: '' })
+    cache.clearNativeChatDraftForSend(key, () => {})
+
+    cache.discardNativeChatDrafts({ sessionIds: ['s-ended'] })
+
+    expect(cache.nativeChatSendsAwaitingHostForTests(key)).toBe(0)
+  })
+
+  it("deletes every pane's draft of a closed terminal tab, and no other tab's", async () => {
+    cache.discardNativeChatDrafts({ terminalTabIds: ['tab-2'] })
+
+    const next = await relaunch()
+    expect(next.readNativeChatDraftCache(next.nativeChatDraftKey(chats.pane))).toBe('')
+    expect(next.readNativeChatDraftCache(next.nativeChatDraftKey(chats.otherPane))).toBe('')
+    expect(next.readNativeChatDraftCache(next.nativeChatDraftKey(chats.otherTab))).toBe('unsent')
+    expect(next.readNativeChatDraftCache(next.nativeChatDraftKey(chats.session))).toBe('unsent')
+  })
+})
+
+describe('another window of the web client', () => {
+  function otherWindowSaves(scopeKey: string, value: string | null): void {
+    const key = `${PREFIX}${encodeURIComponent(scopeKey)}`
+    window.dispatchEvent(new StorageEvent('storage', { key, newValue: value }))
+  }
+
+  it("shows another tab's draft, and its clear at send, instead of re-saving sent text", () => {
+    cache.writeNativeChatDraftCache(SCOPE, 'deploy to prod', 'after-pause')
+    vi.advanceTimersByTime(300)
+    const shown = vi.fn()
+    cache.subscribeToNativeChatDraft(SCOPE, shown)
+
+    otherWindowSaves(SCOPE, null)
+    expect(cache.readNativeChatDraftCache(SCOPE)).toBe('')
+    expect(shown).toHaveBeenCalledTimes(1)
+
+    otherWindowSaves(SCOPE, JSON.stringify({ text: 'from the other tab', attachments: [] }))
+    expect(cache.readNativeChatDraftCache(SCOPE)).toBe('from the other tab')
+  })
+
+  // This tab hears other tabs only once a chat first reads drafts, so that read must be live.
+  it("misses no send another tab made before this tab's chat first read its draft", async () => {
+    cache.writeNativeChatDraftCache(SCOPE, 'deploy to prod', 'now')
+    const next = await relaunch()
+    await (await import('./native-chat-draft-storage')).preloadNativeChatDrafts()
+
+    localStorage.removeItem(`${PREFIX}${encodeURIComponent(SCOPE)}`)
+
+    expect(next.readNativeChatDraftCache(SCOPE)).toBe('')
+  })
+
+  it("keeps this tab's unsaved typing over another tab's write", () => {
+    cache.writeNativeChatDraftCache(SCOPE, 'typing here', 'after-pause')
+
+    otherWindowSaves(SCOPE, JSON.stringify({ text: 'older', attachments: [] }))
+
+    expect(cache.readNativeChatDraftCache(SCOPE)).toBe('typing here')
+  })
+})
+
+// A send goes ahead without a saved clear only when saving failed or was slow; say so in the log.
+describe('a clear that was not saved before the send went on', () => {
+  it('is logged once with its chat and why, never its text', async () => {
+    const writes = installHeldNativeChatDrafts()
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    cache.writeNativeChatDraftCache(SCOPE, 'secret plan', 'now')
+    writes.shift()?.settle('persisted')
+    cache.writeNativeChatDraftCache(SCOPE, '', 'now')
+
+    const waited = cache.awaitNativeChatDraftWritten(SCOPE)
+    await vi.advanceTimersByTimeAsync(250)
+    await waited
+
+    expect(warn).toHaveBeenCalledOnce()
+    expect(warn).toHaveBeenCalledWith(expect.any(String), { scopeKey: SCOPE, reason: 'timed out' })
+    expect(JSON.stringify(warn.mock.calls)).not.toContain('secret plan')
+  })
+
+  it('is logged when the store refused the clear', async () => {
+    const writes = installHeldNativeChatDrafts()
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    cache.writeNativeChatDraftCache(SCOPE, '', 'now')
+
+    const waited = cache.awaitNativeChatDraftWritten(SCOPE)
+    writes.forEach((write) => write.settle('failed'))
+    await waited
+
+    expect(warn).toHaveBeenCalledWith(expect.any(String), { scopeKey: SCOPE, reason: 'failed' })
+  })
+
+  it('is not logged when the browser has no storage to save to', async () => {
+    vi.stubGlobal('localStorage', undefined)
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    cache.writeNativeChatDraftCache(SCOPE, '', 'now')
+
+    await cache.awaitNativeChatDraftWritten(SCOPE)
+
+    expect(warn).not.toHaveBeenCalled()
+  })
+
+  it('is not logged when it was saved', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    cache.writeNativeChatDraftCache(SCOPE, '', 'now')
+
+    await cache.awaitNativeChatDraftWritten(SCOPE)
+
+    expect(warn).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-draft-save-after-send.ts b/src/renderer/src/components/native-chat/native-chat-draft-save-after-send.ts
new file mode 100644
index 00000000000..d8f416689f1
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-draft-save-after-send.ts
@@ -0,0 +1,31 @@
+// What a send does with its chat's saved draft once the message is out of Orca's hands.
+
+import type { NativeChatDraftAttachment } from './native-chat-draft-cache'
+import type { NativeChatSendHandle } from './native-chat-runtime-send'
+
+/** Saves the chat's draft once the terminal has the message: after its scheduled writes ran. */
+export function saveNativeChatDraftAfterPtyWrite(
+  handle: NativeChatSendHandle | null,
+  save: () => void
+): void {
+  if (!handle) {
+    save()
+    return
+  }
+  void (handle.settled ?? new Promise((resolve) => setTimeout(resolve, handle.settleAfterMs))).then(
+    save,
+    save
+  )
+}
+
+/** The draft's copy of composer image chips, for putting a message back. */
+export function nativeChatDraftAttachmentsOf(
+  attachments: readonly NativeChatDraftAttachment[]
+): NativeChatDraftAttachment[] {
+  return attachments.map(({ id, path, connectionId, location }) => ({
+    id,
+    path,
+    ...(connectionId ? { connectionId } : {}),
+    ...(location ? { location } : {})
+  }))
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-draft-send-holds.test.ts b/src/renderer/src/components/native-chat/native-chat-draft-send-holds.test.ts
new file mode 100644
index 00000000000..6029debbfcf
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-draft-send-holds.test.ts
@@ -0,0 +1,43 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from 'vitest'
+import { createNativeChatDraftSendHolds } from './native-chat-draft-send-holds'
+
+const HOLD = { saveAtOnce: false }
+
+describe('send holds', () => {
+  it("skips an earlier send's save while a later one waits, never the other way round", () => {
+    const persist = vi.fn()
+    const holds = createNativeChatDraftSendHolds(persist)
+    const first = holds.clearForSend('chat', () => {}, HOLD)
+    const second = holds.clearForSend('chat', () => {}, HOLD)
+
+    first()
+    expect(persist).not.toHaveBeenCalled()
+    second()
+    expect(persist).toHaveBeenCalledOnce()
+  })
+
+  // Until the agent accepted it, the host may lose a message when Orca quits.
+  it('keeps a hold when the window goes away', () => {
+    const persist = vi.fn()
+    const holds = createNativeChatDraftSendHolds(persist)
+    holds.clearForSend('structured', () => {}, HOLD)
+
+    window.dispatchEvent(new Event('pagehide'))
+    window.dispatchEvent(new Event('beforeunload'))
+
+    expect(persist).not.toHaveBeenCalled()
+  })
+
+  // Chat discards forget its sends; nothing else would, for one that never lands.
+  it("forgets an ended chat's sends", () => {
+    const holds = createNativeChatDraftSendHolds(vi.fn())
+    holds.clearForSend('chat', () => {}, HOLD)
+    holds.clearForSend('other', () => {}, HOLD)
+
+    holds.forget(['chat'])
+
+    expect(holds.sendsAwaitingForTests('chat')).toBe(0)
+    expect(holds.sendsAwaitingForTests('other')).toBe(1)
+  })
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-draft-send-holds.ts b/src/renderer/src/components/native-chat/native-chat-draft-send-holds.ts
new file mode 100644
index 00000000000..232f597639a
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-draft-send-holds.ts
@@ -0,0 +1,78 @@
+// A send empties its chat's box at once but holds back saving that, so a crash before the host has
+// the message restores it unsent. Each hold ends with `save`, which writes the chat's draft as it
+// is then; sends on a chat are numbered, and a save is skipped while a later send still waits.
+
+export type NativeChatDraftSendHolds = {
+  /** Runs `clear` without saving it, unless `saveAtOnce`; returns the hold's `save`. */
+  clearForSend: (
+    draftKey: string,
+    clear: () => void,
+    options: { saveAtOnce: boolean }
+  ) => () => void
+  /** Runs `clear` without saving it; the caller saves the box itself. */
+  clearUnsaved: (draftKey: string, clear: () => void) => void
+  /** Whether a send is clearing this chat's box right now, so the write waits for `save`. */
+  isClearingForSend: (draftKey: string) => boolean
+  /** Forgets the holds of chats that ended. */
+  forget: (draftKeys: Iterable<string>) => void
+  sendsAwaitingForTests: (draftKey: string) => number
+  clearForTests: () => void
+}
+
+export function createNativeChatDraftSendHolds(
+  persist: (draftKey: string) => void
+): NativeChatDraftSendHolds {
+  const clearing = new Set<string>()
+  // Per chat, the sends whose message the host does not have yet, by send order.
+  const awaitingByChat = new Map<string, Set<number>>()
+  let sequence = 0
+
+  const clearUnsaved = (draftKey: string, clear: () => void): void => {
+    clearing.add(draftKey)
+    try {
+      clear()
+    } finally {
+      clearing.delete(draftKey)
+    }
+  }
+
+  return {
+    clearForSend: (draftKey, clear, options) => {
+      const send = (sequence += 1)
+      const awaiting = awaitingByChat.get(draftKey) ?? new Set()
+      awaitingByChat.set(draftKey, awaiting.add(send))
+      if (options.saveAtOnce) {
+        clear()
+      } else {
+        clearUnsaved(draftKey, clear)
+      }
+      const save = (): void => {
+        if (!awaiting.delete(send)) {
+          return
+        }
+        if (awaiting.size === 0 && awaitingByChat.get(draftKey) === awaiting) {
+          awaitingByChat.delete(draftKey)
+        }
+        // A later send still waiting keeps its own message saved, and saves once the host has it.
+        // An earlier one that never lands (held for Retry) holds nothing up.
+        if (Array.from(awaiting).some((later) => later > send)) {
+          return
+        }
+        persist(draftKey)
+      }
+      return save
+    },
+    clearUnsaved,
+    isClearingForSend: (draftKey) => clearing.has(draftKey),
+    forget: (draftKeys) => {
+      for (const draftKey of draftKeys) {
+        awaitingByChat.get(draftKey)?.clear()
+        awaitingByChat.delete(draftKey)
+      }
+    },
+    sendsAwaitingForTests: (draftKey) => awaitingByChat.get(draftKey)?.size ?? 0,
+    clearForTests: () => {
+      awaitingByChat.clear()
+    }
+  }
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-draft-startup-load.test.tsx b/src/renderer/src/components/native-chat/native-chat-draft-startup-load.test.tsx
new file mode 100644
index 00000000000..f3f2f042de4
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-draft-startup-load.test.tsx
@@ -0,0 +1,87 @@
+// @vitest-environment happy-dom
+// A chat's saved draft is in the composer on its first paint after a relaunch: startup loads the
+// drafts before the session hydrates and any chat mounts.
+
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { cleanup, renderHook } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { SavedNativeChatDraft } from '../../../../shared/native-chat-draft-record'
+import { installNativeChatDrafts } from './native-chat-draft-store.test-support'
+
+const SAVED: SavedNativeChatDraft[] = [
+  { scopeKey: 'session:s1', draft: { text: 'half typed', attachments: [] } }
+]
+
+async function relaunch() {
+  vi.resetModules()
+  const storage = await import('./native-chat-draft-storage')
+  const { useNativeChatDraft } = await import('./use-native-chat-draft')
+  return { storage, useNativeChatDraft }
+}
+
+beforeEach(() => {
+  installNativeChatDrafts({
+    load: vi.fn(async () => SAVED),
+    loadSync: vi.fn(() => SAVED),
+    write: vi.fn(async () => 'persisted' as const)
+  })
+})
+
+afterEach(() => cleanup())
+
+describe('saved drafts at startup', () => {
+  it('shows a chat its saved draft on the first render, from the startup load', async () => {
+    const { storage, useNativeChatDraft } = await relaunch()
+    await storage.preloadNativeChatDrafts()
+
+    const firstRenders: string[] = []
+    renderHook(() => {
+      const { draft } = useNativeChatDraft('session:s1', () => false)
+      firstRenders.push(draft)
+    })
+
+    expect(firstRenders[0]).toBe('half typed')
+    expect(window.api.nativeChat.drafts.loadSync).not.toHaveBeenCalled()
+  })
+
+  it('reads the drafts synchronously when a chat mounts before the startup load returned', async () => {
+    const { useNativeChatDraft } = await relaunch()
+
+    const { result } = renderHook(() => useNativeChatDraft('session:s1', () => false))
+
+    expect(result.current.draft).toBe('half typed')
+    expect(window.api.nativeChat.drafts.loadSync).toHaveBeenCalledOnce()
+  })
+
+  it('reads the drafts synchronously when the startup load fails, without failing startup', async () => {
+    installNativeChatDrafts({
+      load: async () => {
+        throw new Error('no reply')
+      },
+      loadSync: () => SAVED,
+      write: async () => 'persisted'
+    })
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const { storage, useNativeChatDraft } = await relaunch()
+
+    await expect(storage.preloadNativeChatDrafts()).resolves.toBeUndefined()
+    const { result } = renderHook(() => useNativeChatDraft('session:s1', () => false))
+    expect(result.current.draft).toBe('half typed')
+  })
+
+  it('loads the drafts before the session hydrates', () => {
+    const source = readFileSync(
+      join(process.cwd(), 'src/renderer/src/app-shell/use-app-startup-hydration.ts'),
+      'utf8'
+    )
+    const loadStart = source.indexOf("'native-chat-drafts-load'")
+    const loadAwait = source.indexOf('await draftsPromise')
+    const hydrate = source.indexOf("'hydrate-session-stores'")
+
+    expect(loadStart).toBeGreaterThanOrEqual(0)
+    expect(loadStart).toBeLessThan(source.indexOf("'session-get'"))
+    expect(loadAwait).toBeGreaterThan(loadStart)
+    expect(loadAwait).toBeLessThan(hydrate)
+  })
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-draft-storage.ts b/src/renderer/src/components/native-chat/native-chat-draft-storage.ts
new file mode 100644
index 00000000000..c926db8c475
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-draft-storage.ts
@@ -0,0 +1,211 @@
+// Saved copy of the composer drafts, so a half-typed message survives quitting Orca. Typing is
+// saved after a short pause and flushed when the page hides or unloads; a put-back is saved at
+// once. A sent message stays saved until the host has it (native-chat-held-sends for structured
+// chats, the cache's send hold for terminal ones), so a crash before that restores the unsent text
+// and a crash after it cannot bring it back. On
+// desktop the main process confirms each write once the file op returned; the web client keeps
+// browser storage, which reaches disk on the browser's own delay, so a browser crash can.
+
+import type {
+  NativeChatDraftStoreResult,
+  PersistedNativeChatDraft,
+  SavedNativeChatDraft
+} from '../../../../shared/native-chat-draft-record'
+
+export type {
+  NativeChatDraftAttachment,
+  NativeChatDraftAttachmentLocation,
+  NativeChatHeldSend,
+  NativeChatTuiInputSeed,
+  PersistedNativeChatDraft
+} from '../../../../shared/native-chat-draft-record'
+export { isEmptyNativeChatDraft } from '../../../../shared/native-chat-draft-record'
+
+/** Whether a write reached disk; a `memory-only` draft is lost when Orca quits. */
+export type NativeChatDraftWriteResult = 'persisted' | 'memory-only'
+
+const TYPING_PERSIST_DELAY_MS = 300
+// Why bounded: saving is bookkeeping; a stalled disk must never hold the user's action back.
+const SAVE_WAIT_BOUND_MS = 250
+
+const pendingDrafts = new Map<string, PersistedNativeChatDraft | null>()
+const pendingTimers = new Map<string, ReturnType<typeof setTimeout>>()
+const latestWrites = new Map<string, Promise<NativeChatDraftStoreResult>>()
+let flushListenersInstalled = false
+let preloaded: SavedNativeChatDraft[] | null = null
+
+function draftStore() {
+  try {
+    return typeof window === 'undefined' ? null : (window.api?.nativeChat?.drafts ?? null)
+  } catch {
+    return null
+  }
+}
+
+async function writeToStore(
+  scopeKey: string,
+  draft: PersistedNativeChatDraft | null
+): Promise<NativeChatDraftStoreResult> {
+  const store = draftStore()
+  if (!store) {
+    return 'unavailable'
+  }
+  try {
+    return await store.write(scopeKey, draft)
+  } catch {
+    return 'failed'
+  }
+}
+
+function cancelPending(scopeKey: string): void {
+  const timer = pendingTimers.get(scopeKey)
+  if (timer !== undefined) {
+    clearTimeout(timer)
+    pendingTimers.delete(scopeKey)
+  }
+  pendingDrafts.delete(scopeKey)
+}
+
+/** Writes now, superseding any delayed write for the scope. `null` removes the saved draft. */
+export function persistNativeChatDraftNow(
+  scopeKey: string,
+  draft: PersistedNativeChatDraft | null
+): Promise<NativeChatDraftWriteResult> {
+  cancelPending(scopeKey)
+  const write = writeToStore(scopeKey, draft)
+  latestWrites.set(scopeKey, write)
+  void write.then(() => {
+    if (latestWrites.get(scopeKey) === write) {
+      latestWrites.delete(scopeKey)
+    }
+  })
+  return write.then((outcome) => (outcome === 'persisted' ? 'persisted' : 'memory-only'))
+}
+
+/**
+ * Settles once the newest write asked for this draft is written, or after a short bound. A queued
+ * message taken back into the box waits here before the host's copy is deleted; a failed or
+ * slow write is logged, and the delete goes ahead.
+ */
+export async function awaitNativeChatDraftSaved(scopeKey: string): Promise<void> {
+  const write = latestWrites.get(scopeKey)
+  if (!write) {
+    return
+  }
+  let timer: ReturnType<typeof setTimeout> | undefined
+  const outcome = await Promise.race([
+    write,
+    new Promise<'timed out'>((resolve) => {
+      timer = setTimeout(() => resolve('timed out'), SAVE_WAIT_BOUND_MS)
+    })
+  ])
+  clearTimeout(timer)
+  if (outcome === 'failed' || outcome === 'timed out') {
+    console.warn('[native-chat] draft not saved before going on', { scopeKey, reason: outcome })
+  }
+}
+
+/** Whether the store saves a send's clear at Enter rather than once the host has the message. */
+export function nativeChatDraftStoreSavesSendClearAtOnce(): boolean {
+  return draftStore()?.savesSendClearAtOnce === true
+}
+
+/** Whether typing for this draft is still waiting for its pause to be saved. */
+export function hasPendingNativeChatDraftPersist(scopeKey: string): boolean {
+  return pendingDrafts.has(scopeKey)
+}
+
+export function flushNativeChatDraftPersists(): void {
+  for (const [scopeKey, draft] of Array.from(pendingDrafts)) {
+    void persistNativeChatDraftNow(scopeKey, draft)
+  }
+}
+
+function installFlushListeners(): void {
+  if (
+    flushListenersInstalled ||
+    typeof window === 'undefined' ||
+    typeof window.addEventListener !== 'function'
+  ) {
+    return
+  }
+  flushListenersInstalled = true
+  window.addEventListener('beforeunload', flushNativeChatDraftPersists)
+  window.addEventListener('pagehide', flushNativeChatDraftPersists)
+  document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'hidden') {
+      flushNativeChatDraftPersists()
+    }
+  })
+}
+
+/** Saves typing after a short pause; the latest draft wins. */
+export function scheduleNativeChatDraftPersist(
+  scopeKey: string,
+  draft: PersistedNativeChatDraft | null
+): void {
+  installFlushListeners()
+  const timer = pendingTimers.get(scopeKey)
+  if (timer !== undefined) {
+    clearTimeout(timer)
+  }
+  pendingDrafts.set(scopeKey, draft)
+  pendingTimers.set(
+    scopeKey,
+    setTimeout(
+      () => void persistNativeChatDraftNow(scopeKey, pendingDrafts.get(scopeKey) ?? null),
+      TYPING_PERSIST_DELAY_MS
+    )
+  )
+}
+
+/** Loads the saved drafts during startup, before any chat mounts. Never fails startup. */
+export async function preloadNativeChatDrafts(): Promise<void> {
+  const store = draftStore()
+  // Why not where other windows write too (web tabs): a snapshot now would miss their changes
+  // until a chat first reads drafts, so that read goes to the store instead.
+  if (!store || store.onExternalChange) {
+    return
+  }
+  try {
+    preloaded = await store.load()
+  } catch (error) {
+    // The first chat to mount reads them synchronously instead.
+    console.warn('[native-chat] could not load saved drafts', error)
+  }
+}
+
+/** The saved drafts, oldest first; read synchronously if startup did not preload them. */
+export function loadPersistedNativeChatDrafts(): SavedNativeChatDraft[] {
+  if (!preloaded) {
+    try {
+      preloaded = draftStore()?.loadSync() ?? []
+    } catch {
+      preloaded = []
+    }
+  }
+  return preloaded
+}
+
+/**
+ * Calls back when another window changes a saved draft (a second browser tab of the web client).
+ * A key with a write still pending here is skipped: this window's draft is newer.
+ */
+export function observeOtherWindowNativeChatDrafts(
+  onChange: (scopeKey: string, draft: PersistedNativeChatDraft | null) => void
+): void {
+  draftStore()?.onExternalChange?.((scopeKey, draft) => {
+    if (!pendingDrafts.has(scopeKey)) {
+      onChange(scopeKey, draft)
+    }
+  })
+}
+
+export function resetNativeChatDraftStorageForTests(): void {
+  for (const scopeKey of Array.from(pendingTimers.keys())) {
+    cancelPending(scopeKey)
+  }
+  pendingDrafts.clear()
+  latestWrites.clear()
+  preloaded = null
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-draft-store.test-support.ts b/src/renderer/src/components/native-chat/native-chat-draft-store.test-support.ts
new file mode 100644
index 00000000000..69c5ec38e96
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-draft-store.test-support.ts
@@ -0,0 +1,50 @@
+import type { NativeChatDraftsApi } from '../../../../preload/api-types'
+import type { NativeChatDraftStoreResult } from '../../../../shared/native-chat-draft-record'
+import { createWebNativeChatDrafts } from '../../web/preload-api/web-native-chat-drafts'
+
+/** Puts `drafts` on `window.api.nativeChat`, keeping whatever else the test installed. */
+export function installNativeChatDrafts(drafts: NativeChatDraftsApi): void {
+  const api: Record<string, unknown> = { ...window.api }
+  const nativeChat: Record<string, unknown> = { ...window.api?.nativeChat }
+  Object.defineProperty(window, 'api', {
+    configurable: true,
+    writable: true,
+    value: { ...api, nativeChat: { ...nativeChat, drafts } }
+  })
+}
+
+/**
+ * Saves drafts in localStorage, as the web client does, so a test can read them back. Starts
+ * empty: drafts an earlier test saved are removed. `like: 'desktop'` saves a send's clear once
+ * the host has the message, as the desktop store does.
+ */
+export function installLocalStorageNativeChatDrafts(
+  options: { like?: 'web' | 'desktop' } = {}
+): NativeChatDraftsApi {
+  const { savesSendClearAtOnce: _web, ...desktop } = createWebNativeChatDrafts()
+  const drafts = options.like === 'desktop' ? desktop : createWebNativeChatDrafts()
+  for (const { scopeKey } of drafts.loadSync()) {
+    // Settles synchronously: browser storage has no async step.
+    void drafts.write(scopeKey, null)
+  }
+  installNativeChatDrafts(drafts)
+  return drafts
+}
+
+export type HeldNativeChatDraftWrite = {
+  scopeKey: string
+  draft: unknown
+  settle: (result: NativeChatDraftStoreResult) => void
+}
+
+/** A store whose writes stay unconfirmed until the test settles them, as a slow disk would. */
+export function installHeldNativeChatDrafts(): HeldNativeChatDraftWrite[] {
+  const writes: HeldNativeChatDraftWrite[] = []
+  installNativeChatDrafts({
+    load: async () => [],
+    loadSync: () => [],
+    write: (scopeKey, draft) =>
+      new Promise((resolve) => writes.push({ scopeKey, draft, settle: resolve }))
+  })
+  return writes
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-held-sends.test.tsx b/src/renderer/src/components/native-chat/native-chat-held-sends.test.tsx
new file mode 100644
index 00000000000..a6616d4b16a
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-held-sends.test.tsx
@@ -0,0 +1,173 @@
+// A sent message is kept beside the chat's live draft until the host holds it. After a crash, the
+// relaunched chat's journal decides each held send: dropped when the host holds it, otherwise put
+// back into the box after anything typed. The live draft is never hidden or held back meanwhile.
+
+// @vitest-environment happy-dom
+
+import { act, cleanup, renderHook } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import type { AgentSessionQueuedMessage } from '../../../../shared/agent-session-queued-message-wire'
+import type { NativeChatDraftsApi } from '../../../../preload/api-types'
+import type { PersistedNativeChatDraft } from '../../../../shared/native-chat-draft-record'
+import { installLocalStorageNativeChatDrafts } from './native-chat-draft-store.test-support'
+
+const CHAT = 'session:s1'
+const PREFIX = 'orca:nativeChatComposerDraft:v1:'
+
+function saved(): PersistedNativeChatDraft | null {
+  const raw = localStorage.getItem(`${PREFIX}${encodeURIComponent(CHAT)}`)
+  return raw ? JSON.parse(raw) : null
+}
+
+function submission(
+  clientMessageId: string,
+  dispatchState: AgentJournalSubmission['dispatchState'],
+  overrides: Partial<AgentJournalSubmission> = {}
+): AgentJournalSubmission {
+  return {
+    clientMessageId,
+    fence: 1,
+    payloadFingerprint: 'fingerprint',
+    dispatchState,
+    providerItemId: null,
+    reason: null,
+    submittedAt: 1,
+    resolvedAt: null,
+    handoverRecorded: true,
+    ...overrides
+  }
+}
+
+function card(messageId: string): AgentSessionQueuedMessage {
+  return {
+    messageId,
+    position: 1,
+    body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'sent once' }] },
+    state: 'waiting'
+  }
+}
+
+type Journal = {
+  status: 'idle' | 'loading' | 'ready' | 'error'
+  submissions: readonly AgentJournalSubmission[]
+  queuedMessages?: readonly AgentSessionQueuedMessage[]
+}
+
+let store: NativeChatDraftsApi
+
+/** A fresh renderer: module memory is gone, only the saved drafts remain. */
+async function relaunch() {
+  vi.resetModules()
+  const cache = await import('./native-chat-draft-cache')
+  const heldSends = await import('./native-chat-held-sends')
+  const { useNativeChatHeldSends } = await import('./use-native-chat-held-sends')
+  const view = renderHook((journal: Journal) => useNativeChatHeldSends(CHAT, journal), {
+    initialProps: { status: 'loading', submissions: [] }
+  })
+  return { cache, heldSends, view }
+}
+
+beforeEach(async () => {
+  localStorage.clear()
+  store = installLocalStorageNativeChatDrafts({ like: 'desktop' })
+  // The earlier run: the box was being edited when a send of 'sent once' was still held.
+  await store.write(CHAT, {
+    text: 'typed before',
+    attachments: [],
+    importedOutboxEntryIds: ['old-outbox-entry'],
+    heldSends: [{ clientMessageId: 'm1', text: 'sent once', attachments: [], sentAt: 5 }]
+  })
+})
+
+afterEach(() => {
+  cleanup()
+})
+
+describe('a relaunch with a held send left by a crash', () => {
+  it.each([
+    ['the agent accepted it', { submissions: [submission('m1', 'accepted')] }],
+    ['the host keeps it as a card', { submissions: [], queuedMessages: [card('m1')] }],
+    [
+      'a submission handed that card off',
+      { submissions: [submission('h1', 'pending', { queuedMessageId: 'm1' })] }
+    ]
+  ] as const)('drops it when %s', async (_label, journal) => {
+    const { cache, view } = await relaunch()
+
+    view.rerender({ status: 'ready', ...journal })
+    await act(async () => {})
+
+    expect(cache.readNativeChatDraftCache(CHAT)).toBe('typed before')
+    expect(saved()?.heldSends).toBeUndefined()
+    expect(saved()?.importedOutboxEntryIds).toEqual(['old-outbox-entry'])
+  })
+
+  it.each([
+    ['has no submission for it', []],
+    ['has it pending, not yet accepted by the agent', [submission('m1', 'pending')]]
+  ] as const)('puts it back after the box when the journal %s', async (_label, submissions) => {
+    const { cache, view } = await relaunch()
+
+    view.rerender({ status: 'ready', submissions })
+    await act(async () => {})
+
+    expect(cache.readNativeChatDraftCache(CHAT)).toBe('typed before\n\nsent once')
+    expect(saved()).toMatchObject({
+      text: 'typed before\n\nsent once',
+      importedOutboxEntryIds: ['old-outbox-entry']
+    })
+    expect(saved()?.heldSends).toBeUndefined()
+  })
+
+  it('puts it back when the journal cannot be read, even one that holds it', async () => {
+    const { cache, view } = await relaunch()
+
+    view.rerender({ status: 'error', submissions: [submission('m1', 'accepted')] })
+    await act(async () => {})
+
+    expect(cache.readNativeChatDraftCache(CHAT)).toBe('typed before\n\nsent once')
+  })
+
+  it('shows and saves the box at once, and keeps a send made while the journal is read', async () => {
+    const { cache, heldSends, view } = await relaunch()
+    expect(cache.readNativeChatDraftCache(CHAT)).toBe('typed before')
+
+    cache.writeNativeChatDraftCache(CHAT, 'second message', 'now')
+    await act(async () => {})
+    expect(saved()).toMatchObject({
+      text: 'second message',
+      heldSends: [{ clientMessageId: 'm1' }]
+    })
+
+    act(() => heldSends.holdNativeChatDraftSend(CHAT, { text: 'second message' }, 'm2'))
+    act(() => cache.writeNativeChatDraftCache(CHAT, '', 'now'))
+    await act(async () => {})
+    expect(saved()?.heldSends?.map((send) => send.clientMessageId)).toEqual(['m1', 'm2'])
+
+    view.rerender({ status: 'ready', submissions: [] })
+    await act(async () => {})
+
+    // Only the earlier run's send goes back; this run's still waits for its host.
+    expect(cache.readNativeChatDraftCache(CHAT)).toBe('sent once')
+    expect(saved()?.heldSends?.map((send) => send.clientMessageId)).toEqual(['m2'])
+  })
+})
+
+describe('a held send in a running session', () => {
+  it('goes when the journal shows the host holds it, and stays while it is only pending', async () => {
+    await store.write(CHAT, null)
+    const { cache, heldSends, view } = await relaunch()
+    act(() => heldSends.holdNativeChatDraftSend(CHAT, { text: 'live send' }, 'm3'))
+    await act(async () => {})
+
+    view.rerender({ status: 'ready', submissions: [submission('m3', 'pending')] })
+    await act(async () => {})
+    expect(saved()?.heldSends?.map((send) => send.text)).toEqual(['live send'])
+    expect(cache.readNativeChatDraftCache(CHAT)).toBe('')
+
+    view.rerender({ status: 'ready', submissions: [submission('m3', 'accepted')] })
+    await act(async () => {})
+    expect(saved()).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-held-sends.ts b/src/renderer/src/components/native-chat/native-chat-held-sends.ts
new file mode 100644
index 00000000000..71cf12a0412
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-held-sends.ts
@@ -0,0 +1,107 @@
+// A structured send's message is kept beside the chat's live draft, as a held send, from Enter
+// until the host holds it. Typing and later sends change only the live draft, so nothing waits on
+// the host and nothing is saved over a held send. After a relaunch the chat's journal decides each
+// one the earlier run left: dropped when the host holds it, otherwise put back into the box.
+
+import {
+  appendNativeChatDraftNow,
+  readNativeChatDraftCache,
+  readNativeChatDraftHeldSends,
+  updateNativeChatDraftHeldSends,
+  type NativeChatDraftContent
+} from './native-chat-draft-cache'
+import { nativeChatDraftStoreSavesSendClearAtOnce } from './native-chat-draft-storage'
+import { takeRestoredNativeChatHeldSends } from './native-chat-restored-held-sends'
+
+/**
+ * Saves the box a structured send just cleared, with the sent message as a held send under the id
+ * the host will know it by, in one write. With no id (nothing reached the outbox) only the box is
+ * saved. The web client saved the clear at Enter and holds no copy.
+ */
+export function holdNativeChatDraftSend(
+  draftKey: string,
+  sent: NativeChatDraftContent,
+  clientMessageId: string | undefined
+): void {
+  if (nativeChatDraftStoreSavesSendClearAtOnce()) {
+    return
+  }
+  const held = clientMessageId
+    ? [
+        {
+          clientMessageId,
+          text: sent.text,
+          attachments: sent.attachments ?? [],
+          sentAt: Date.now()
+        }
+      ]
+    : []
+  updateNativeChatDraftHeldSends(draftKey, (heldSends) => [...heldSends, ...held])
+}
+
+/** The host holds this send (or it was withdrawn or dropped): its held copy goes. */
+export function releaseNativeChatHeldSend(draftKey: string, clientMessageId: string): void {
+  if (
+    readNativeChatDraftHeldSends(draftKey).some((send) => send.clientMessageId === clientMessageId)
+  ) {
+    updateNativeChatDraftHeldSends(draftKey, (heldSends) =>
+      heldSends.filter((send) => send.clientMessageId !== clientMessageId)
+    )
+  }
+}
+
+/** A refusal gave the send a new id; the host will know it by that one. */
+export function renameNativeChatHeldSend(draftKey: string, from: string, to: string): void {
+  if (readNativeChatDraftHeldSends(draftKey).some((send) => send.clientMessageId === from)) {
+    updateNativeChatDraftHeldSends(draftKey, (heldSends) =>
+      heldSends.map((send) =>
+        send.clientMessageId === from ? { ...send, clientMessageId: to } : send
+      )
+    )
+  }
+}
+
+/** Drops every held send of the chat the host holds, as its journal shows them. */
+export function releaseNativeChatHeldSendsTheHostHolds(
+  draftKey: string,
+  hostHolds: (clientMessageId: string) => boolean
+): void {
+  for (const send of readNativeChatDraftHeldSends(draftKey)) {
+    if (hostHolds(send.clientMessageId)) {
+      releaseNativeChatHeldSend(draftKey, send.clientMessageId)
+    }
+  }
+}
+
+/**
+ * The chat's journal answered for the first time since a relaunch: each held send the earlier run
+ * left goes back into the box, after anything typed meanwhile, unless the host holds it. Called
+ * with `hostHolds` false for every id when the journal cannot be read: shown twice beats lost.
+ */
+export function settleRestoredNativeChatHeldSends(
+  draftKey: string,
+  hostHolds: (clientMessageId: string) => boolean
+): void {
+  // Loads the saved drafts if nothing read them yet, which is what finds the restored sends.
+  readNativeChatDraftCache(draftKey)
+  const restored = takeRestoredNativeChatHeldSends(draftKey)
+  if (!restored) {
+    return
+  }
+  for (const send of readNativeChatDraftHeldSends(draftKey)) {
+    if (!restored.has(send.clientMessageId)) {
+      continue
+    }
+    if (hostHolds(send.clientMessageId)) {
+      releaseNativeChatHeldSend(draftKey, send.clientMessageId)
+      continue
+    }
+    // The held send leaves in the same write that puts its text back.
+    updateNativeChatDraftHeldSends(
+      draftKey,
+      (heldSends) => heldSends.filter((held) => held.clientMessageId !== send.clientMessageId),
+      { save: false }
+    )
+    void appendNativeChatDraftNow(draftKey, { text: send.text, attachments: send.attachments })
+  }
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-resolved-path-ownership.ts b/src/renderer/src/components/native-chat/native-chat-resolved-path-ownership.ts
index 86290338167..04e5e3ab48f 100644
--- a/src/renderer/src/components/native-chat/native-chat-resolved-path-ownership.ts
+++ b/src/renderer/src/components/native-chat/native-chat-resolved-path-ownership.ts
@@ -4,6 +4,8 @@ import type { NativeChatAttachmentOwner } from './native-chat-attachment-upload'
 export type NativeChatResolvedPathOptions = {
   /** Revalidates internal path ownership when an IME-delayed attachment is applied. */
   targetOwnerIsCurrent?: () => boolean
+  /** The paths live on the workspace's runtime server, not on this machine. */
+  onRuntimeHost?: boolean
 }
 
 export function nativeChatWorkspaceAttachmentMismatchNotice(): string {
diff --git a/src/renderer/src/components/native-chat/native-chat-restored-held-sends.ts b/src/renderer/src/components/native-chat/native-chat-restored-held-sends.ts
new file mode 100644
index 00000000000..f15722c9450
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-restored-held-sends.ts
@@ -0,0 +1,30 @@
+// The held sends a relaunch loaded, per chat. They wait for the chat's journal to say whether the
+// host holds each; sends made since the relaunch are not among them.
+
+const restoredByChat = new Map<string, Set<string>>()
+
+export function noteRestoredNativeChatHeldSends(
+  draftKey: string,
+  heldSends: readonly { clientMessageId: string }[] | undefined
+): void {
+  if (heldSends?.length) {
+    restoredByChat.set(draftKey, new Set(heldSends.map((send) => send.clientMessageId)))
+  }
+}
+
+/** Removes and returns the ids of the chat's restored held sends, so they are judged once. */
+export function takeRestoredNativeChatHeldSends(draftKey: string): ReadonlySet<string> | undefined {
+  const restored = restoredByChat.get(draftKey)
+  restoredByChat.delete(draftKey)
+  return restored
+}
+
+export function forgetRestoredNativeChatHeldSends(draftKeys: Iterable<string>): void {
+  for (const draftKey of draftKeys) {
+    restoredByChat.delete(draftKey)
+  }
+}
+
+export function clearRestoredNativeChatHeldSendsForTests(): void {
+  restoredByChat.clear()
+}
diff --git a/src/renderer/src/components/native-chat/native-chat-structured-composer-dispatch.ts b/src/renderer/src/components/native-chat/native-chat-structured-composer-dispatch.ts
index a620bf71038..4c45b46c91e 100644
--- a/src/renderer/src/components/native-chat/native-chat-structured-composer-dispatch.ts
+++ b/src/renderer/src/components/native-chat/native-chat-structured-composer-dispatch.ts
@@ -1,14 +1,17 @@
 import type { NativeChatStructuredComposerTransport } from './native-chat-composer-types'
 import type { NativeChatComposerImageAttachment } from './NativeChatComposerField'
 
+/** `beforeSend` runs only when the text goes out as a message, right before the transport takes it. */
 export async function dispatchNativeChatStructuredComposerText(
   transport: NativeChatStructuredComposerTransport,
   text: string,
-  attachments: readonly NativeChatComposerImageAttachment[] = []
+  attachments: readonly NativeChatComposerImageAttachment[] = [],
+  beforeSend?: () => void
 ): Promise<{ accepted: boolean; error: string | null }> {
   const command = await transport.dispatchCommand(text)
   if (command.handled) {
     return { accepted: command.accepted, error: command.error }
   }
+  beforeSend?.()
   return { accepted: transport.send(text, attachments), error: null }
 }
diff --git a/src/renderer/src/components/native-chat/native-chat-structured-send-composition-clear.test.tsx b/src/renderer/src/components/native-chat/native-chat-structured-send-composition-clear.test.tsx
index 298da7fba6a..a31dcb6e156 100644
--- a/src/renderer/src/components/native-chat/native-chat-structured-send-composition-clear.test.tsx
+++ b/src/renderer/src/components/native-chat/native-chat-structured-send-composition-clear.test.tsx
@@ -67,7 +67,26 @@ vi.mock('../dictation/dictation-control-events', () => ({
 }))
 
 import { NativeChatComposer } from './NativeChatComposer'
-import { appendNativeChatDraftCache, readNativeChatDraftCache } from './native-chat-draft-cache'
+import {
+  installLocalStorageNativeChatDrafts,
+  installNativeChatDrafts
+} from './native-chat-draft-store.test-support'
+import {
+  appendStructuredAgentSessionOutboxMessage,
+  commitStructuredAgentSessionOutbox,
+  getStructuredAgentSessionOutbox
+} from './structured-agent-session-outbox-storage'
+import { noteStructuredAgentSessionMessagesDelivered } from './structured-agent-session-message-delivery'
+import {
+  flushNativeChatDraftPersists,
+  type PersistedNativeChatDraft
+} from './native-chat-draft-storage'
+import {
+  appendNativeChatDraftNow,
+  clearNativeChatDraftCacheForTests,
+  nativeChatDraftKey,
+  readNativeChatDraftCache
+} from './native-chat-draft-cache'
 
 type Dispatched = { handled: boolean; accepted: boolean; error: string | null }
 
@@ -96,7 +115,7 @@ function transport(
     optionSnapshot: [],
     onError: vi.fn(),
     runtime: 'remote',
-    sessionId: 'session-test',
+    sessionId: `session-${paneCounter + 1}`,
     runtimeEnvironmentId: null,
     ...overrides
   }
@@ -106,18 +125,23 @@ function textarea(): HTMLTextAreaElement {
   return screen.getByRole('textbox') as HTMLTextAreaElement
 }
 
-function pressEnter(input: HTMLTextAreaElement): void {
+function pressEnter(input: HTMLElement): void {
   fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, isComposing: false })
 }
 
 let paneCounter = 0
 
+// The chat draft of the composer rendered last.
+let draftKey = ''
+
 function renderComposer(structuredTransport: NativeChatStructuredComposerTransport): void {
   paneCounter += 1
+  const paneKey = `tab-${paneCounter}:structured`
+  draftKey = nativeChatDraftKey({ sessionId: structuredTransport.sessionId, paneKey })
   render(
     <NativeChatComposer
       terminalTabId={`tab-${paneCounter}`}
-      paneKey={`tab-${paneCounter}:structured`}
+      paneKey={paneKey}
       targetPtyId={null}
       agent="codex"
       structuredTransport={structuredTransport}
@@ -134,6 +158,7 @@ beforeEach(() => {
       ui: { onFileDrop: () => vi.fn() }
     }
   })
+  installLocalStorageNativeChatDrafts()
 })
 
 afterEach(() => cleanup())
@@ -187,8 +212,7 @@ describe('structured send racing the next IME composition', () => {
     expect(promptValue(input)).toBe('가')
   })
 
-  // Clearing optimistically before the RPC would lose the draft here, which is why the clear
-  // stays on the acceptance path and is instead replayed at settlement.
+  // The message is cleared just before the transport takes it, so a refusal must put it back.
   it('keeps the draft when the send is rejected', async () => {
     const structured = transport({ send: vi.fn(() => false) })
     renderComposer(structured)
@@ -201,6 +225,7 @@ describe('structured send racing the next IME composition', () => {
     expect(promptValue(input)).toBe('안녕')
   })
 
+  // Like any put-back, the refused message lands after what was composed meanwhile.
   it('keeps the draft when a rejected send races the next composition', async () => {
     const dispatch = deferred()
     const structured = transport({
@@ -222,7 +247,7 @@ describe('structured send racing the next IME composition', () => {
     })
     fireEvent.compositionEnd(input, { data: '하' })
 
-    expect(promptValue(input)).toBe('안녕하')
+    expect(promptValue(input)).toBe('하\n\n안녕')
   })
 
   // A rejected command still reports its error, and the composer keeps the text to retry.
@@ -247,13 +272,13 @@ describe('a withdrawn message put back during an IME composition', () => {
   // wrote the draft without the text, after its outbox entry had already been dropped.
   it('shows the text once the composition settles, after what was composed', () => {
     renderComposer(transport())
-    const pane = `tab-${paneCounter}:structured`
+    const pane = draftKey
     const input = textarea()
     changePrompt(input, 'abc')
 
     fireEvent.compositionStart(input)
     changePrompt(input, 'abc안')
-    act(() => appendNativeChatDraftCache(pane, 'withdrawn'))
+    act(() => void appendNativeChatDraftNow(pane, { text: 'withdrawn' }))
     changePrompt(input, 'abc안녕')
     fireEvent.compositionEnd(input, { data: '안녕' })
 
@@ -264,12 +289,12 @@ describe('a withdrawn message put back during an IME composition', () => {
   // Settling spends the held text; a later write or composition must not add it again.
   it('shows the text once, however much is typed or composed after', () => {
     renderComposer(transport())
-    const pane = `tab-${paneCounter}:structured`
+    const pane = draftKey
     const input = textarea()
     changePrompt(input, 'abc')
     fireEvent.compositionStart(input)
     changePrompt(input, 'abc안')
-    act(() => appendNativeChatDraftCache(pane, 'withdrawn'))
+    act(() => void appendNativeChatDraftNow(pane, { text: 'withdrawn' }))
     fireEvent.compositionEnd(input, { data: '안' })
 
     changePrompt(input, 'abc안\n\nwithdrawn!')
@@ -286,14 +311,14 @@ describe('a withdrawn message put back during an IME composition', () => {
     const dispatch = deferred()
     const structured = transport({ dispatchCommand: vi.fn(() => dispatch.promise) })
     renderComposer(structured)
-    const pane = `tab-${paneCounter}:structured`
+    const pane = draftKey
     const input = textarea()
     changePrompt(input, '안녕')
     pressEnter(input)
 
     fireEvent.compositionStart(input)
     changePrompt(input, '안녕하')
-    act(() => appendNativeChatDraftCache(pane, 'withdrawn'))
+    act(() => void appendNativeChatDraftNow(pane, { text: 'withdrawn' }))
     await act(async () => {
       dispatch.resolve(PASS_THROUGH)
       await dispatch.promise
@@ -304,3 +329,534 @@ describe('a withdrawn message put back during an IME composition', () => {
     expect(readNativeChatDraftCache(pane)).toBe('하\n\nwithdrawn')
   })
 })
+
+// A crash before the host has the message must restore it unsent, and one after must not bring it
+// back, so the box's clear is saved only once the host has it.
+describe('the saved draft at send', () => {
+  beforeEach(() => {
+    clearNativeChatDraftCacheForTests()
+    installLocalStorageNativeChatDrafts({ like: 'desktop' })
+  })
+
+  function savedRecord(): PersistedNativeChatDraft | null {
+    const raw = localStorage.getItem(
+      `orca:nativeChatComposerDraft:v1:${encodeURIComponent(draftKey)}`
+    )
+    return raw ? JSON.parse(raw) : null
+  }
+
+  function savedText(): string | null {
+    return savedRecord()?.text ?? null
+  }
+
+  // The sent messages the saved draft still holds, beside its live text.
+  function savedHeld(): string[] {
+    return savedRecord()?.heldSends?.map((send) => send.text) ?? []
+  }
+
+  // The real outbox, so the test can play the host taking the message.
+  function outboxTransport(): NativeChatStructuredComposerTransport {
+    const structured = transport()
+    structured.send = vi.fn(
+      (text: string) =>
+        appendStructuredAgentSessionOutboxMessage(structured.sessionId, text) !== null
+    )
+    return structured
+  }
+
+  // A settled refusal: the message stays for Retry under a new id.
+  function hostRefusesWithNewId(
+    structured: NativeChatStructuredComposerTransport,
+    entry: ReturnType<typeof getStructuredAgentSessionOutbox>[number]
+  ): void {
+    act(() => {
+      commitStructuredAgentSessionOutbox(structured.sessionId, [
+        { ...entry, clientMessageId: 'rotated-id', state: 'rejected' }
+      ])
+    })
+  }
+
+  function hostTakes(structured: NativeChatStructuredComposerTransport): void {
+    act(() => {
+      commitStructuredAgentSessionOutbox(structured.sessionId, [])
+    })
+  }
+
+  async function sendTyped(structured: NativeChatStructuredComposerTransport, text: string) {
+    renderComposer(structured)
+    const input = textarea()
+    changePrompt(input, text)
+    act(() => flushNativeChatDraftPersists())
+    await act(async () => pressEnter(input))
+    return input
+  }
+
+  it('keeps the message saved until the host has it, then saves the empty box', async () => {
+    const structured = outboxTransport()
+    const input = await sendTyped(structured, 'ship it')
+
+    expect(structured.send).toHaveBeenCalledOnce()
+    expect(promptValue(input)).toBe('')
+    expect(savedText()).toBe('')
+    expect(savedHeld()).toEqual(['ship it'])
+
+    hostTakes(structured)
+    await act(async () => {})
+    expect(savedRecord()).toBeNull()
+  })
+
+  // "Sent" is the host's ok reply: a message it holds for the provider must not come back.
+  it('saves the box once the host holds the message for good, while it waits for the provider', async () => {
+    const structured = outboxTransport()
+    await sendTyped(structured, 'mid-turn message')
+    const [pending] = getStructuredAgentSessionOutbox(structured.sessionId)
+
+    act(() =>
+      noteStructuredAgentSessionMessagesDelivered(structured.sessionId, [pending.clientMessageId])
+    )
+    await act(async () => {})
+
+    expect(getStructuredAgentSessionOutbox(structured.sessionId)).toHaveLength(1)
+    expect(savedText()).toBeNull()
+  })
+
+  it('keeps a message the host refused, under its new id, until that one is delivered', async () => {
+    const structured = outboxTransport()
+    await sendTyped(structured, 'refused message')
+    const [first] = getStructuredAgentSessionOutbox(structured.sessionId)
+
+    hostRefusesWithNewId(structured, first)
+    expect(savedRecord()?.heldSends).toMatchObject([
+      { clientMessageId: 'rotated-id', text: 'refused message' }
+    ])
+
+    act(() => noteStructuredAgentSessionMessagesDelivered(structured.sessionId, ['rotated-id']))
+    await act(async () => {})
+    expect(savedRecord()).toBeNull()
+  })
+
+  it('releases a later send the host holds while an earlier one waits for Retry', async () => {
+    const structured = outboxTransport()
+    const input = await sendTyped(structured, 'message A')
+    const [held] = getStructuredAgentSessionOutbox(structured.sessionId)
+    act(() => {
+      commitStructuredAgentSessionOutbox(structured.sessionId, [{ ...held, state: 'rejected' }])
+    })
+
+    changePrompt(input, 'message B')
+    act(() => flushNativeChatDraftPersists())
+    await act(async () => pressEnter(input))
+    const later = getStructuredAgentSessionOutbox(structured.sessionId).filter(
+      (entry) => entry.clientMessageId !== held.clientMessageId
+    )
+    act(() =>
+      noteStructuredAgentSessionMessagesDelivered(
+        structured.sessionId,
+        later.map((entry) => entry.clientMessageId)
+      )
+    )
+    await act(async () => {})
+
+    expect(savedHeld()).toEqual(['message A'])
+  })
+
+  it('releases only the send the host holds while a later one still waits', async () => {
+    const structured = outboxTransport()
+    const input = await sendTyped(structured, 'message A')
+    const [first] = getStructuredAgentSessionOutbox(structured.sessionId)
+    changePrompt(input, 'message B')
+    act(() => flushNativeChatDraftPersists())
+    await act(async () => pressEnter(input))
+
+    act(() =>
+      noteStructuredAgentSessionMessagesDelivered(structured.sessionId, [first.clientMessageId])
+    )
+    await act(async () => {})
+
+    expect(savedText()).toBe('')
+    expect(savedHeld()).toEqual(['message B'])
+  })
+
+  // Case 12: a send while the agent works, then a normal quit. Until the agent accepted it, the host
+  // may lose the message when Orca quits, so both copies stay: the outbox entry and the saved draft.
+  it.each(['pagehide', 'beforeunload'])(
+    'keeps the saved message and its outbox entry when the window goes away (%s)',
+    async (event) => {
+      const structured = outboxTransport()
+      await sendTyped(structured, 'queued while working')
+      expect(savedHeld()).toEqual(['queued while working'])
+
+      act(() => window.dispatchEvent(new Event(event)))
+      await act(async () => {})
+
+      expect(savedHeld()).toEqual(['queued while working'])
+      expect(getStructuredAgentSessionOutbox(structured.sessionId)).toHaveLength(1)
+    }
+  )
+
+  // The whole clear a real send does: text, image chips and the editor. No write of the emptied
+  // box may reach the store before the host has the message.
+  it('writes nothing without the message until the host has it, with images attached', async () => {
+    Object.defineProperty(window, 'api', {
+      configurable: true,
+      value: {
+        ...window.api,
+        fs: {
+          authorizeExternalPath: vi.fn(async () => {}),
+          pathsExist: vi.fn(async () => [{ exists: true }])
+        }
+      }
+    })
+    const drafts = installLocalStorageNativeChatDrafts({ like: 'desktop' })
+    const saves: (PersistedNativeChatDraft | null)[] = []
+    installNativeChatDrafts({
+      ...drafts,
+      write: (scopeKey, draft) => {
+        saves.push(draft)
+        return drafts.write(scopeKey, draft)
+      }
+    })
+    const holdsMessage = (draft: PersistedNativeChatDraft | null): boolean =>
+      [draft, ...(draft?.heldSends ?? [])].some(
+        (copy) => copy?.text === 'look at this' && copy.attachments.length === 1
+      )
+    const structured = outboxTransport()
+    const chat = nativeChatDraftKey({ sessionId: structured.sessionId, paneKey: '' })
+    act(
+      () =>
+        void appendNativeChatDraftNow(chat, {
+          text: 'look at this',
+          attachments: [{ id: 'shot', path: '/shot.png', location: 'local' }]
+        })
+    )
+    renderComposer(structured)
+    await act(async () => {})
+    const input = textarea()
+    saves.length = 0
+
+    await act(async () => pressEnter(input))
+    await act(async () => {})
+
+    expect(structured.send).toHaveBeenCalledOnce()
+    expect(promptValue(input)).toBe('')
+    expect(saves.filter((save) => !holdsMessage(save))).toEqual([])
+    expect(savedHeld()).toEqual(['look at this'])
+
+    hostTakes(structured)
+    await act(async () => {})
+    expect(saves.at(-1)).toBeNull()
+  })
+
+  // A crash can never find the box saved empty without the message it sent.
+  it('saves the emptied box and the sent message, under its id, in one write', async () => {
+    const drafts = installLocalStorageNativeChatDrafts({ like: 'desktop' })
+    const saves: (PersistedNativeChatDraft | null)[] = []
+    installNativeChatDrafts({
+      ...drafts,
+      write: (scopeKey, draft) => {
+        saves.push(draft)
+        return drafts.write(scopeKey, draft)
+      }
+    })
+    const structured = outboxTransport()
+    renderComposer(structured)
+    const input = textarea()
+    changePrompt(input, 'ship it')
+    act(() => flushNativeChatDraftPersists())
+    saves.length = 0
+
+    await act(async () => pressEnter(input))
+    await act(async () => {})
+    const [entry] = getStructuredAgentSessionOutbox(structured.sessionId)
+
+    expect(saves).toEqual([
+      {
+        text: '',
+        attachments: [],
+        heldSends: [
+          {
+            clientMessageId: entry.clientMessageId,
+            text: 'ship it',
+            attachments: [],
+            sentAt: expect.any(Number)
+          }
+        ]
+      }
+    ])
+  })
+
+  it('keeps what was typed after Enter when the host takes the message', async () => {
+    const structured = outboxTransport()
+    const input = await sendTyped(structured, 'ship it')
+
+    changePrompt(input, 'and then')
+    hostTakes(structured)
+    await act(async () => {})
+
+    expect(savedText()).toBe('and then')
+  })
+
+  // Browser storage reaches disk lazily anyway; clearing first frees the quota the outbox append
+  // shares with drafts, so a large draft cannot make that append, and the send, fail.
+  it('saves the clear at Enter in the web client, before the outbox takes the message', async () => {
+    installLocalStorageNativeChatDrafts()
+    const seenBySend: (string | null)[] = []
+    const structured = transport()
+    structured.send = vi.fn((text: string) => {
+      seenBySend.push(savedText())
+      return appendStructuredAgentSessionOutboxMessage(structured.sessionId, text) !== null
+    })
+    const input = await sendTyped(structured, 'a long message')
+
+    expect(seenBySend).toEqual([null])
+    expect(promptValue(input)).toBe('')
+  })
+
+  it('leaves the saved message alone, and puts it back in the box, when the send is refused', async () => {
+    const drafts = installLocalStorageNativeChatDrafts({ like: 'desktop' })
+    const saves: (string | null)[] = []
+    installNativeChatDrafts({
+      ...drafts,
+      write: (scopeKey, draft) => {
+        saves.push(draft?.text ?? null)
+        return drafts.write(scopeKey, draft)
+      }
+    })
+    const structured = transport({ send: vi.fn(() => false) })
+    const input = await sendTyped(structured, 'ship it')
+
+    expect(promptValue(input)).toBe('ship it')
+    expect(savedText()).toBe('ship it')
+    expect(saves).not.toContain(null)
+  })
+})
+
+describe('the draft saved to disk', () => {
+  beforeEach(() => clearNativeChatDraftCacheForTests())
+
+  // A clear left to the typing delay would let a crash right after Enter bring the sent text back.
+  it('is removed the moment the send is accepted', async () => {
+    renderComposer(transport())
+    const key = `orca:nativeChatComposerDraft:v1:${encodeURIComponent(draftKey)}`
+    const input = textarea()
+    changePrompt(input, 'ship it')
+    act(() => window.dispatchEvent(new Event('pagehide')))
+    expect(JSON.parse(localStorage.getItem(key) ?? 'null')).toMatchObject({ text: 'ship it' })
+
+    await act(async () => pressEnter(input))
+
+    expect(localStorage.getItem(key)).toBeNull()
+  })
+
+  // Sending would hand the agent a path to nothing; the chip says so and Send waits for its removal.
+  it('will not send a restored image whose file is gone until the chip is removed', async () => {
+    const structured = transport()
+    Object.defineProperty(window, 'api', {
+      configurable: true,
+      value: {
+        ...window.api,
+        fs: { pathsExist: vi.fn(async () => [{ exists: false }]) }
+      }
+    })
+    const chat = nativeChatDraftKey({ sessionId: structured.sessionId, paneKey: '' })
+    appendNativeChatDraftNow(chat, {
+      text: 'look at this',
+      attachments: [{ id: 'gone', path: '/gone.png', location: 'local' }]
+    })
+    renderComposer(structured)
+    await act(async () => {})
+
+    await act(async () => pressEnter(textarea()))
+    expect(structured.send).not.toHaveBeenCalled()
+    expect(
+      screen.getByRole('button', { name: /Image no longer available\. Remove it to send\./ })
+    ).toBeTruthy()
+    // The reason Send is held is shown without hovering the chip.
+    expect(screen.getByText('Image no longer available. Remove it to send.')).toBeTruthy()
+
+    fireEvent.click(screen.getByRole('button', { name: 'Remove attachment' }))
+    expect(screen.queryByText('Image no longer available. Remove it to send.')).toBeNull()
+    await act(async () => pressEnter(textarea()))
+    expect(structured.send).toHaveBeenCalledWith('look at this', [])
+  })
+
+  // The composing box still holds the sent text; its keystrokes must not save it again before the
+  // composition settles, or a crash meanwhile restores it and the next Enter sends it twice.
+  it('never gets the sent text back from a composition the clear landed in', async () => {
+    vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] })
+    try {
+      const dispatch = deferred()
+      renderComposer(transport({ dispatchCommand: vi.fn(() => dispatch.promise) }))
+      const key = `orca:nativeChatComposerDraft:v1:${encodeURIComponent(draftKey)}`
+      const input = textarea()
+      changePrompt(input, '안녕')
+      pressEnter(input)
+      fireEvent.compositionStart(input)
+      changePrompt(input, '안녕하')
+      await act(async () => {
+        dispatch.resolve(PASS_THROUGH)
+        await dispatch.promise
+      })
+
+      changePrompt(input, '안녕하나')
+      act(() => vi.advanceTimersByTime(1000))
+
+      expect(readNativeChatDraftCache(draftKey)).toBe('')
+      expect(localStorage.getItem(key)).toBeNull()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('keeps a put-back but not the sent text when both land mid-composition', async () => {
+    vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] })
+    try {
+      const dispatch = deferred()
+      renderComposer(transport({ dispatchCommand: vi.fn(() => dispatch.promise) }))
+      const pane = draftKey
+      const key = `orca:nativeChatComposerDraft:v1:${encodeURIComponent(pane)}`
+      const input = textarea()
+      changePrompt(input, '안녕')
+      pressEnter(input)
+      fireEvent.compositionStart(input)
+      changePrompt(input, '안녕하')
+      act(() => void appendNativeChatDraftNow(pane, { text: 'withdrawn' }))
+      await act(async () => {
+        dispatch.resolve(PASS_THROUGH)
+        await dispatch.promise
+      })
+
+      changePrompt(input, '안녕하나')
+      act(() => vi.advanceTimersByTime(1000))
+
+      expect(readNativeChatDraftCache(pane)).toBe('withdrawn')
+      expect(JSON.parse(localStorage.getItem(key) ?? 'null')).toMatchObject({ text: 'withdrawn' })
+      fireEvent.compositionEnd(input, { data: '하나' })
+      expect(readNativeChatDraftCache(pane)).toBe('하나\n\nwithdrawn')
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
+
+describe('one chat shown in two panes', () => {
+  beforeEach(() => clearNativeChatDraftCacheForTests())
+
+  function renderTwoPanes(): {
+    first: HTMLElement
+    second: HTMLElement
+    structured: NativeChatStructuredComposerTransport
+  } {
+    const structured = transport()
+    paneCounter += 1
+    const panes = [`tab-${paneCounter}:first`, `tab-${paneCounter}:second`]
+    draftKey = nativeChatDraftKey({ sessionId: structured.sessionId, paneKey: panes[0] })
+    render(
+      <>
+        {panes.map((paneKey) => (
+          <NativeChatComposer
+            key={paneKey}
+            terminalTabId={`tab-${paneCounter}`}
+            paneKey={paneKey}
+            targetPtyId={null}
+            agent="codex"
+            structuredTransport={structured}
+          />
+        ))}
+      </>
+    )
+    const [first, second] = screen.getAllByRole('textbox')
+    return { first, second, structured }
+  }
+
+  it('shows typing from either pane in the other, losing no keystrokes', () => {
+    const { first, second } = renderTwoPanes()
+
+    changePrompt(first, 'hello')
+    expect(promptValue(second)).toBe('hello')
+    changePrompt(second, 'hello world')
+    expect(promptValue(first)).toBe('hello world')
+    changePrompt(first, 'hello world!')
+
+    expect(promptValue(second)).toBe('hello world!')
+    expect(readNativeChatDraftCache(draftKey)).toBe('hello world!')
+  })
+
+  it('empties every pane when one sends', async () => {
+    const { first, second, structured } = renderTwoPanes()
+    changePrompt(first, 'ship it')
+
+    await act(async () => pressEnter(second))
+
+    expect(structured.send).toHaveBeenCalledWith('ship it', [])
+    expect(promptValue(first)).toBe('')
+    expect(promptValue(second)).toBe('')
+  })
+
+  it('shows text put back by a Stop in every pane', () => {
+    const { first, second } = renderTwoPanes()
+
+    act(() => void appendNativeChatDraftNow(draftKey, { text: 'withdrawn' }))
+
+    expect(promptValue(first)).toBe('withdrawn')
+    expect(promptValue(second)).toBe('withdrawn')
+  })
+
+  // The live composition owns its field, as against every programmatic draft: the other pane's
+  // text must neither break the composition nor be written over it until it settles.
+  it('leaves a composition intact when the other pane writes mid-composition', () => {
+    const { first, second } = renderTwoPanes()
+    changePrompt(second, 'abc')
+
+    fireEvent.compositionStart(second)
+    changePrompt(second, 'abc안')
+    changePrompt(first, 'from the other pane')
+    expect(promptValue(second)).toBe('abc안')
+    changePrompt(second, 'abc안녕')
+    fireEvent.compositionEnd(second, { data: '안녕' })
+
+    expect(promptValue(second)).toBe('abc안녕')
+    expect(promptValue(first)).toBe('abc안녕')
+    expect(readNativeChatDraftCache(draftKey)).toBe('abc안녕')
+  })
+
+  it('keeps the settled composition when the other pane wrote after its last keystroke', () => {
+    const { first, second } = renderTwoPanes()
+    changePrompt(second, 'abc')
+
+    fireEvent.compositionStart(second)
+    changePrompt(second, 'abc안')
+    changePrompt(first, 'from the other pane')
+    fireEvent.compositionEnd(second, { data: '안' })
+
+    expect(promptValue(second)).toBe('abc안')
+    expect(promptValue(first)).toBe('abc안')
+    expect(readNativeChatDraftCache(draftKey)).toBe('abc안')
+  })
+
+  it('keeps only the composed segment when the other pane sends mid-composition', async () => {
+    const { first, second } = renderTwoPanes()
+    changePrompt(first, 'sent')
+
+    fireEvent.compositionStart(second)
+    await act(async () => pressEnter(first))
+    changePrompt(second, 'sent하')
+    fireEvent.compositionEnd(second, { data: '하' })
+
+    expect(promptValue(second)).toBe('하')
+    expect(promptValue(first)).toBe('하')
+    expect(readNativeChatDraftCache(draftKey)).toBe('하')
+  })
+
+  it('never shows the sent text again in the sending pane while the other pane composes', async () => {
+    const { first, second } = renderTwoPanes()
+    changePrompt(first, 'sent')
+
+    fireEvent.compositionStart(second)
+    await act(async () => pressEnter(first))
+    changePrompt(second, 'sent하')
+
+    expect(promptValue(first)).toBe('')
+    expect(readNativeChatDraftCache(draftKey)).toBe('')
+  })
+})
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-message-delivery.ts b/src/renderer/src/components/native-chat/structured-agent-session-message-delivery.ts
new file mode 100644
index 00000000000..2c2b8273370
--- /dev/null
+++ b/src/renderer/src/components/native-chat/structured-agent-session-message-delivery.ts
@@ -0,0 +1,153 @@
+// Tells a composer when the host has a message it sent for good, so the chat's saved draft can stop
+// holding it: the agent accepted it, or the host queued it as a card (both kept across quit and
+// restart), by the send's reply or the journal (`structuredAgentSessionHostHoldsMessage`).
+// A message withdrawn back into the box, or dropped, also settles; one refused, rejected or still
+// unconfirmed keeps its draft copy until it is delivered or leaves. A refusal that gives the entry
+// a new id is followed to that id.
+
+import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import type { StructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
+
+type Watched = { queuedAt: number; body: string; renamed?: (from: string, to: string) => void }
+type Watcher = { messages: Map<string, Watched>; settle: () => void }
+
+const watchersBySession = new Map<string, Set<Watcher>>()
+
+function forEachWatcher(sessionId: string, visit: (watcher: Watcher) => void): void {
+  const watchers = watchersBySession.get(sessionId)
+  if (!watchers) {
+    return
+  }
+  for (const watcher of Array.from(watchers)) {
+    visit(watcher)
+    if (watcher.messages.size === 0) {
+      watchers.delete(watcher)
+      watcher.settle()
+    }
+  }
+  if (watchers.size === 0) {
+    watchersBySession.delete(sessionId)
+  }
+}
+
+/**
+ * Whether the host holds a submission past quit and restart: only once the agent accepted it. A
+ * pending one can still be lost: not handed over yet, the host rejects it when Orca quits or after
+ * a crash; handed over but not in the agent's history, a reopen settles it as never delivered.
+ */
+export function structuredAgentSessionSubmissionHeldForGood(
+  submission: Pick<AgentJournalSubmission, 'dispatchState'>
+): boolean {
+  return submission.dispatchState === 'accepted'
+}
+
+/** What the host holds for a chat, as its journal or a send's reply shows it. */
+export type StructuredAgentSessionHostCopies = {
+  submissions: readonly Pick<
+    AgentJournalSubmission,
+    'clientMessageId' | 'dispatchState' | 'queuedMessageId'
+  >[]
+  cards: readonly { messageId: string; state: string }[]
+}
+
+// A card the host keeps (its `queued_messages` row); a withdrawn one went back to its sender.
+const HELD_CARD_STATES: ReadonlySet<string> = new Set(['waiting', 'returned', 'dispatched'])
+
+/**
+ * Whether the host holds message `clientMessageId` for good: the agent accepted it, the host keeps
+ * it as a card, or a submission handed that card off. The one rule for releasing a sent message's
+ * saved copy, in the session and after a relaunch; the planned relaxation switches only this.
+ */
+export function structuredAgentSessionHostHoldsMessage(
+  host: StructuredAgentSessionHostCopies,
+  clientMessageId: string
+): boolean {
+  return (
+    host.submissions.some(
+      (submission) =>
+        submission.queuedMessageId === clientMessageId ||
+        (submission.clientMessageId === clientMessageId &&
+          structuredAgentSessionSubmissionHeldForGood(submission))
+    ) ||
+    host.cards.some(
+      (card) => card.messageId === clientMessageId && HELD_CARD_STATES.has(card.state)
+    )
+  )
+}
+
+/**
+ * Settles once the host has every one of `entries` (or each was withdrawn or dropped). `renamed`
+ * hears when a refusal gives an entry a new id, which is then watched instead.
+ */
+export function whenStructuredAgentSessionHostHasMessages(
+  sessionId: string,
+  entries: readonly StructuredAgentSessionOutboxEntry[],
+  renamed?: (from: string, to: string) => void
+): Promise<void> {
+  if (entries.length === 0) {
+    return Promise.resolve()
+  }
+  return new Promise((settle) => {
+    const messages = new Map(
+      entries.map((entry): [string, Watched] => [
+        entry.clientMessageId,
+        { queuedAt: entry.queuedAt, body: JSON.stringify(entry.body), renamed }
+      ])
+    )
+    const watchers = watchersBySession.get(sessionId) ?? new Set()
+    watchersBySession.set(sessionId, watchers)
+    watchers.add({ messages, settle })
+  })
+}
+
+/** The host's reply to these sends shows it holds them. */
+export function noteStructuredAgentSessionMessagesDelivered(
+  sessionId: string,
+  clientMessageIds: Iterable<string>
+): void {
+  const delivered = new Set(clientMessageIds)
+  forEachWatcher(sessionId, (watcher) => {
+    for (const id of delivered) {
+      watcher.messages.delete(id)
+    }
+  })
+}
+
+/** A message left the outbox undelivered: its draft copy is the only one, so nothing saves over it. */
+export function keepStructuredAgentSessionMessageDraft(
+  sessionId: string,
+  clientMessageId: string
+): void {
+  const watchers = watchersBySession.get(sessionId)
+  for (const watcher of Array.from(watchers ?? [])) {
+    if (watcher.messages.has(clientMessageId)) {
+      watchers?.delete(watcher)
+    }
+  }
+}
+
+/** Every outbox write: a watched entry that left settles, unless it only took a new id. */
+export function observeStructuredAgentSessionOutboxWrite(
+  sessionId: string,
+  entries: readonly StructuredAgentSessionOutboxEntry[]
+): void {
+  const present = new Set(entries.map((entry) => entry.clientMessageId))
+  forEachWatcher(sessionId, (watcher) => {
+    for (const [id, watched] of Array.from(watcher.messages)) {
+      if (present.has(id)) {
+        continue
+      }
+      watcher.messages.delete(id)
+      const renamed = entries.find(
+        (entry) =>
+          !watcher.messages.has(entry.clientMessageId) &&
+          entry.queuedAt === watched.queuedAt &&
+          JSON.stringify(entry.body) === watched.body
+      )
+      if (renamed) {
+        watcher.messages.set(renamed.clientMessageId, watched)
+        watched.renamed?.(id, renamed.clientMessageId)
+      }
+    }
+  })
+}
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-outbox-dispatch.delivery.test.ts b/src/renderer/src/components/native-chat/structured-agent-session-outbox-dispatch.delivery.test.ts
new file mode 100644
index 00000000000..7e827573d98
--- /dev/null
+++ b/src/renderer/src/components/native-chat/structured-agent-session-outbox-dispatch.delivery.test.ts
@@ -0,0 +1,193 @@
+// @vitest-environment happy-dom
+// A composer's saved draft keeps a sent message until the host has it. "Has it" is the host's ok
+// reply to the send (pending, accepted or queued), not the provider's acceptance; a refusal, a
+// rejection or a send dropped unconfirmed keeps the draft copy, and a new id is followed.
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type {
+  AgentSessionMutationResult,
+  AgentSessionSendResult
+} from '../../../../shared/agent-session-wire'
+import type {
+  AgentJournalDispatchState,
+  AgentJournalSubmission
+} from '../../../../shared/agent-session-journal-types'
+import type { StructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
+import { refuseUnclassified } from '../../../../shared/agent-session-wire-refusals'
+
+const reply = vi.hoisted(() => ({ call: vi.fn() }))
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: reply.call
+}))
+
+import { dispatchStructuredAgentSessionOutboxEntry } from './structured-agent-session-outbox-dispatch'
+import {
+  appendStructuredAgentSessionOutboxMessage,
+  commitStructuredAgentSessionOutbox,
+  getStructuredAgentSessionOutbox
+} from './structured-agent-session-outbox-storage'
+import {
+  noteStructuredAgentSessionMessagesDelivered,
+  whenStructuredAgentSessionHostHasMessages
+} from './structured-agent-session-message-delivery'
+
+const SESSION = 'session-delivery'
+
+function submission(
+  clientMessageId: string,
+  dispatchState: AgentJournalDispatchState,
+  overrides: Partial<AgentJournalSubmission> = {}
+): AgentJournalSubmission {
+  return {
+    clientMessageId,
+    fence: 1,
+    payloadFingerprint: 'fingerprint',
+    dispatchState,
+    providerItemId: null,
+    reason: null,
+    submittedAt: 1,
+    resolvedAt: null,
+    ...overrides
+  }
+}
+
+function ok(value: AgentSessionSendResult): AgentSessionMutationResult<AgentSessionSendResult> {
+  return { ok: true, replayed: false, fence: 1, cursor: { epoch: 'epoch', sequence: 1 }, value }
+}
+
+async function sendWithReply(
+  answer: (
+    entry: StructuredAgentSessionOutboxEntry
+  ) => AgentSessionMutationResult<AgentSessionSendResult>,
+  prepare: (entry: StructuredAgentSessionOutboxEntry) => StructuredAgentSessionOutboxEntry = (
+    entry
+  ) => entry
+): Promise<() => boolean> {
+  const appended = appendStructuredAgentSessionOutboxMessage(SESSION, 'hello')
+  if (!appended) {
+    throw new Error('outbox append failed')
+  }
+  const entry = prepare(appended)
+  commitStructuredAgentSessionOutbox(SESSION, [entry])
+  let settled = false
+  void whenStructuredAgentSessionHostHasMessages(SESSION, [entry]).then(() => {
+    settled = true
+  })
+  reply.call.mockResolvedValueOnce(answer(entry))
+  const dispatch = dispatchStructuredAgentSessionOutboxEntry({
+    next: entry,
+    entries: getStructuredAgentSessionOutbox(SESSION),
+    sessionId: SESSION,
+    target: { kind: 'local' },
+    fence: 1,
+    dispatchGeneration: 0,
+    dispatchGenerationRef: { current: 0 },
+    inFlightIdRef: { current: null },
+    setError: () => {},
+    applyDisposition: (disposition) => {
+      commitStructuredAgentSessionOutbox(SESSION, disposition.entries)
+    },
+    createOperationId: () => 'rotated-id'
+  })
+  await dispatch.promise
+  await Promise.resolve()
+  return () => settled
+}
+
+beforeEach(() => {
+  localStorage.clear()
+  commitStructuredAgentSessionOutbox(SESSION, [])
+})
+
+afterEach(() => {
+  reply.call.mockReset()
+})
+
+describe("a sent message's saved draft", () => {
+  it('is released by an accepted reply', async () => {
+    const hostHasIt = await sendWithReply((entry) =>
+      ok({
+        clientMessageId: entry.clientMessageId,
+        submission: submission(entry.clientMessageId, 'accepted')
+      })
+    )
+
+    expect(hostHasIt()).toBe(true)
+  })
+
+  // Until the agent accepts it the host can still lose it: not handed over, it is rejected when
+  // Orca quits or after a crash; handed over (a send mid-turn joins the running turn at once) but
+  // not in the agent's history, a reopen settles it as never delivered.
+  it.each([
+    ['not handed over yet', { handoverRecorded: true }],
+    ['handed over into the running turn', { handoverRecorded: true, handedOverAt: 5 }],
+    ['from an older host', {}]
+  ] as const)(
+    'is kept for a pending reply %s, until the agent accepts it',
+    async (_label, overrides) => {
+      const hostHasIt = await sendWithReply((entry) =>
+        ok({
+          clientMessageId: entry.clientMessageId,
+          submission: submission(entry.clientMessageId, 'pending', overrides)
+        })
+      )
+      expect(hostHasIt()).toBe(false)
+
+      const [entry] = getStructuredAgentSessionOutbox(SESSION)
+      noteStructuredAgentSessionMessagesDelivered(SESSION, [entry.clientMessageId])
+      await Promise.resolve()
+      expect(hostHasIt()).toBe(true)
+    }
+  )
+
+  it('is released by a queued reply', async () => {
+    const hostHasIt = await sendWithReply((entry) =>
+      ok({
+        clientMessageId: entry.clientMessageId,
+        queued: { messageId: entry.clientMessageId, position: 1, state: 'waiting' }
+      })
+    )
+
+    expect(hostHasIt()).toBe(true)
+  })
+
+  it('is kept for a rejected message, which stays for Retry', async () => {
+    const hostHasIt = await sendWithReply((entry) =>
+      ok({
+        clientMessageId: entry.clientMessageId,
+        submission: submission(entry.clientMessageId, 'rejected', { reason: 'no' })
+      })
+    )
+
+    expect(hostHasIt()).toBe(false)
+  })
+
+  it('follows a refusal that gave the message a new id, and is released once that one lands', async () => {
+    const hostHasIt = await sendWithReply(() => ({
+      ok: false,
+      refusal: refuseUnclassified('agent_session_owner_restart_failed', 'restart failed')
+    }))
+    expect(getStructuredAgentSessionOutbox(SESSION).map((entry) => entry.clientMessageId)).toEqual([
+      'rotated-id'
+    ])
+    expect(hostHasIt()).toBe(false)
+
+    noteStructuredAgentSessionMessagesDelivered(SESSION, ['rotated-id'])
+    await Promise.resolve()
+    expect(hostHasIt()).toBe(true)
+  })
+
+  it('is kept for a send the host dropped with its delivery unconfirmed', async () => {
+    const hostHasIt = await sendWithReply(
+      (entry) =>
+        ok({
+          clientMessageId: entry.clientMessageId,
+          submission: submission(entry.clientMessageId, 'unknown', { submittedAt: 7 })
+        }),
+      (entry) => ({ ...entry, state: 'unconfirmed', retryAfterUnknownSubmittedAt: 7 })
+    )
+
+    expect(getStructuredAgentSessionOutbox(SESSION)).toEqual([])
+    expect(hostHasIt()).toBe(false)
+  })
+})
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-outbox-dispatch.ts b/src/renderer/src/components/native-chat/structured-agent-session-outbox-dispatch.ts
index e96e447e9ea..a936eb2f827 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-outbox-dispatch.ts
+++ b/src/renderer/src/components/native-chat/structured-agent-session-outbox-dispatch.ts
@@ -24,6 +24,11 @@ import {
   commitStructuredAgentSessionOutbox,
   getStructuredAgentSessionOutbox
 } from './structured-agent-session-outbox-storage'
+import {
+  keepStructuredAgentSessionMessageDraft,
+  noteStructuredAgentSessionMessagesDelivered,
+  structuredAgentSessionHostHoldsMessage
+} from './structured-agent-session-message-delivery'
 import {
   getStructuredAgentLaunchPromptDispatch,
   shareStructuredAgentLaunchPromptDispatch
@@ -123,14 +128,14 @@ export function dispatchStructuredAgentSessionOutboxEntry(args: {
       if (args.dispatchGenerationRef.current !== args.dispatchGeneration) {
         return false
       }
-      args.applyDisposition(
-        disposeStructuredAgentSessionSendResult({
-          entries: getStructuredAgentSessionOutbox(args.sessionId),
-          entry: args.next,
-          result,
-          createOperationId: args.createOperationId
-        })
-      )
+      const disposition = disposeStructuredAgentSessionSendResult({
+        entries: getStructuredAgentSessionOutbox(args.sessionId),
+        entry: args.next,
+        result,
+        createOperationId: args.createOperationId
+      })
+      noteSendReply(args.sessionId, args.next.clientMessageId, result, disposition.entries)
+      args.applyDisposition(disposition)
       if (!result.ok) {
         return false
       }
@@ -174,3 +179,27 @@ export function dispatchStructuredAgentSessionOutboxEntry(args: {
       )
     : { promise: start(), started: true }
 }
+
+// Before the reply's outbox write, so the composer's saved draft follows the host's answer.
+function noteSendReply(
+  sessionId: string,
+  clientMessageId: string,
+  result: AgentSessionMutationResult<AgentSessionSendResult>,
+  entries: readonly StructuredAgentSessionOutboxEntry[]
+): void {
+  if (!result.ok) {
+    // Refused: the entry stays, perhaps under a new id, for the user's Retry.
+    return
+  }
+  const reply = result.value
+  const host =
+    'queued' in reply
+      ? { submissions: [], cards: [reply.queued] }
+      : { submissions: [reply.submission], cards: [] }
+  if (structuredAgentSessionHostHoldsMessage(host, clientMessageId)) {
+    noteStructuredAgentSessionMessagesDelivered(sessionId, [clientMessageId])
+  } else if (!entries.some((entry) => entry.clientMessageId === clientMessageId)) {
+    // Dropped with delivery unconfirmed: the draft's copy is all that is left.
+    keepStructuredAgentSessionMessageDraft(sessionId, clientMessageId)
+  }
+}
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-outbox-storage.ts b/src/renderer/src/components/native-chat/structured-agent-session-outbox-storage.ts
index ce270d60ddb..4ac7339a6f4 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-outbox-storage.ts
+++ b/src/renderer/src/components/native-chat/structured-agent-session-outbox-storage.ts
@@ -6,6 +6,7 @@ import {
 } from '../../../../shared/structured-agent-session-outbox'
 import { createStructuredAgentSessionOperationId } from '../../../../shared/structured-agent-session-mutation'
 import { createBrowserUuid } from '@/lib/browser-uuid'
+import { observeStructuredAgentSessionOutboxWrite } from './structured-agent-session-message-delivery'
 
 const OUTBOX_PREFIX = 'orca:desktopStructuredAgentSessionOutbox:v1:'
 
@@ -86,6 +87,7 @@ export function writeOutbox(
   sessionId: string,
   entries: readonly StructuredAgentSessionOutboxEntry[]
 ): boolean {
+  observeStructuredAgentSessionOutboxWrite(sessionId, entries)
   try {
     if (entries.length === 0) {
       localStorage.removeItem(storageKey(sessionId))
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.test.tsx b/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.test.tsx
index 150b520bcd3..cf27bb250be 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.test.tsx
+++ b/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.test.tsx
@@ -15,6 +15,9 @@ import {
 } from '../../../../shared/structured-agent-session-dispatch-rejection'
 
 type SendParams = { envelope?: { clientOperationId: string } }
+import type * as AttachmentUploadModule from './native-chat-attachment-upload'
+import type { NativeChatAttachmentOwner } from './native-chat-attachment-upload'
+
 type ReadState = { submissions: AgentJournalSubmission[]; items: AgentJournalRenderItem[] }
 
 const mocks = vi.hoisted(() => {
@@ -22,10 +25,18 @@ const mocks = vi.hoisted(() => {
   return {
     call: vi.fn<(target: unknown, method: string, params: SendParams) => Promise<unknown>>(),
     toastError: vi.fn(),
+    resolveOwner: vi.fn<(...args: unknown[]) => NativeChatAttachmentOwner>(() => ({
+      kind: 'local'
+    })),
     read
   }
 })
 
+vi.mock('./native-chat-attachment-upload', async (importOriginal) => ({
+  ...(await importOriginal<typeof AttachmentUploadModule>()),
+  resolveNativeChatAttachmentOwnerForWorktree: mocks.resolveOwner
+}))
+
 vi.mock('@/runtime/structured-agent-session-client', () => ({
   callStructuredAgentSession: mocks.call,
   supportsStructuredAgentSessionPromptCancel: vi.fn(async () => false)
@@ -54,19 +65,16 @@ import {
 } from '../../../../shared/protocol-version'
 import { setLocalRuntimeCapabilitiesForTests } from '@/runtime/local-runtime-capabilities'
 import {
-  appendNativeChatDraftCache,
+  appendNativeChatDraftNow,
   clearNativeChatDraftCacheForTests,
+  readNativeChatDraftAttachments,
   readNativeChatDraftCache,
   subscribeToNativeChatDraftAppend,
   writeNativeChatDraftCache
 } from './native-chat-draft-cache'
-import {
-  appendNativeChatAttachmentCache,
-  clearNativeChatAttachmentCacheForTests,
-  readNativeChatAttachmentCache,
-  useNativeChatComposerAttachments
-} from './use-native-chat-composer-attachments'
+import { useNativeChatComposerAttachments } from './use-native-chat-composer-attachments'
 import { useNativeChatDraft } from './use-native-chat-draft'
+import { installLocalStorageNativeChatDrafts } from './native-chat-draft-store.test-support'
 import {
   enqueueStructuredAgentSessionLaunchPrompt,
   readOutbox,
@@ -135,7 +143,7 @@ function renderOutbox(composerScopeKey: string | null = PANE) {
         target,
         fence: 1,
         submissions: props.submissions,
-        ...(composerScopeKey ? { composerScopeKey } : {})
+        ...(composerScopeKey ? { composerScopeKey, composerWorktreeId: 'wt-1' } : {})
       }),
     { initialProps: { submissions: NONE } }
   )
@@ -163,8 +171,8 @@ afterEach(() => {
 beforeEach(() => {
   vi.clearAllMocks()
   localStorage.clear()
+  installLocalStorageNativeChatDrafts()
   clearNativeChatDraftCacheForTests()
-  clearNativeChatAttachmentCacheForTests()
   mocks.read.submissions = []
   mocks.read.items = []
   let uuid = 0
@@ -182,8 +190,11 @@ describe('a message the host withdrew at a Stop', () => {
     'comes back to the composer with its images, after the draft, when %s',
     async (_case, handover) => {
       answerSendsPending()
-      writeNativeChatDraftCache(PANE, 'already typed')
-      appendNativeChatAttachmentCache(PANE, [{ id: 'typed', path: '/tmp/typed.png' }])
+      writeNativeChatDraftCache(PANE, 'already typed', 'after-pause')
+      appendNativeChatDraftNow(PANE, {
+        text: '',
+        attachments: [{ id: 'typed', path: '/tmp/typed.png' }]
+      })
       const { result, rerender } = renderOutbox()
       const id = await sendToHost(result, 'hello', [
         { path: '/tmp/shot.png', previewUri: '/tmp/shot.png' }
@@ -194,13 +205,79 @@ describe('a message the host withdrew at a Stop', () => {
 
       await waitFor(() => expect(result.current.outbox).toEqual([]))
       expect(readNativeChatDraftCache(PANE)).toBe('already typed\n\nhello')
-      expect(readNativeChatAttachmentCache(PANE)).toEqual([
+      expect(readNativeChatDraftAttachments(PANE)).toEqual([
         { id: 'typed', path: '/tmp/typed.png' },
-        { id: expect.any(String), path: '/tmp/shot.png' }
+        { id: expect.any(String), path: '/tmp/shot.png', location: 'local' }
       ])
     }
   )
 
+  // The outbox keeps only the path; where the file lives comes from the chat's owner, as for a
+  // new image, so a deleted local one is still caught and an SSH one is still asked there.
+  it('gives a returned image the location its chat attaches images in', async () => {
+    answerSendsPending()
+    const pathsExist = vi.fn(async ({ filePaths }: { filePaths: string[] }) =>
+      filePaths.map(() => ({ exists: false }))
+    )
+    Object.defineProperty(window, 'api', {
+      configurable: true,
+      value: { fs: { authorizeExternalPath: vi.fn(async () => {}), pathsExist } }
+    })
+    const { result, rerender } = renderOutbox()
+    const id = await sendToHost(result, 'hello', [
+      { path: '/tmp/shot.png', previewUri: '/tmp/shot.png' }
+    ])
+    rerender({ submissions: [withdrawn(id, {})] })
+    await waitFor(() => expect(readNativeChatDraftAttachments(PANE)).toHaveLength(1))
+
+    const view = renderHook(() =>
+      useNativeChatComposerAttachments({
+        attachmentScopeKey: PANE,
+        allowWithoutTarget: true,
+        caret: 0,
+        disabled: false,
+        isComposing: () => false,
+        resolveTarget: () => null,
+        textareaRef: { current: null },
+        setCaret: () => {},
+        setDraft: () => {},
+        setNotice: () => {}
+      })
+    )
+    await waitFor(() => expect(view.result.current.imageAttachments[0]?.missing).toBe(true))
+    expect(pathsExist).toHaveBeenCalledWith({ filePaths: ['/tmp/shot.png'] })
+  })
+
+  it('keeps an SSH chat connection on a returned image', async () => {
+    answerSendsPending()
+    mocks.resolveOwner.mockReturnValueOnce({
+      kind: 'ssh',
+      connectionId: 'ssh-1',
+      worktreePath: '/remote/wt',
+      expectedExecutionHostId: 'ssh:target-1',
+      expectedSshTargetId: 'target-1',
+      expectedSshConnectionGeneration: 1
+    })
+    const { result, rerender } = renderOutbox()
+    const id = await sendToHost(result, 'hello', [
+      { path: '/remote/tmp/shot.png', previewUri: '/remote/tmp/shot.png' }
+    ])
+
+    rerender({ submissions: [withdrawn(id, {})] })
+
+    await waitFor(() =>
+      expect(readNativeChatDraftAttachments(PANE)).toEqual([
+        {
+          id: expect.any(String),
+          path: '/remote/tmp/shot.png',
+          connectionId: 'ssh-1',
+          location: 'ssh'
+        }
+      ])
+    )
+    expect(mocks.resolveOwner).toHaveBeenCalledWith(expect.anything(), 'wt-1')
+  })
+
   it('comes back when the host wrote the withdrawal as a typed fact in a sentence', async () => {
     answerSendsPending()
     const { result, rerender } = renderOutbox()
@@ -433,19 +510,20 @@ describe('an open composer', () => {
     const { result } = renderHook(() => useNativeChatDraft(PANE, notComposing))
     act(() => result.current.setDraft('typed'))
 
-    act(() => appendNativeChatDraftCache(PANE, 'hello'))
+    act(() => void appendNativeChatDraftNow(PANE, { text: 'hello' }))
 
     expect(result.current.draft).toBe('typed\n\nhello')
   })
 
+  // An unsettled composition reaches the chat only when it settles; the put-back is saved already.
   it('keeps text put back mid-composition through the composed writes, even if it unmounts', () => {
     const { result, unmount } = renderHook(() => useNativeChatDraft(PANE, () => true))
-    act(() => appendNativeChatDraftCache(PANE, 'hello'))
+    act(() => void appendNativeChatDraftNow(PANE, { text: 'hello' }))
     act(() => result.current.setDraft('typed'))
 
     expect(result.current.draft).toBe('typed')
     unmount()
-    expect(readNativeChatDraftCache(PANE)).toBe('typed\n\nhello')
+    expect(readNativeChatDraftCache(PANE)).toBe('hello')
   })
 
   it('shows images put back while it is open, beside the ones attached', () => {
@@ -465,7 +543,13 @@ describe('an open composer', () => {
     )
     act(() => result.current.attachResolvedPaths(['/tmp/typed.png']))
 
-    act(() => appendNativeChatAttachmentCache(PANE, [{ id: 'restored', path: '/tmp/shot.png' }]))
+    act(
+      () =>
+        void appendNativeChatDraftNow(PANE, {
+          text: '',
+          attachments: [{ id: 'restored', path: '/tmp/shot.png' }]
+        })
+    )
 
     expect(result.current.imageAttachments.map((attachment) => attachment.path)).toEqual([
       '/tmp/typed.png',
diff --git a/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.ts b/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.ts
index 40e69565ef0..280c684510e 100644
--- a/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.ts
+++ b/src/renderer/src/components/native-chat/structured-agent-session-withdrawn-message-restore.ts
@@ -2,9 +2,13 @@ import { useMemo } from 'react'
 import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
 import { dispatchWasWithdrawn } from '../../../../shared/structured-agent-session-dispatch-rejection'
 import type { StructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
-import { appendNativeChatDraftCache } from './native-chat-draft-cache'
+import { useAppStore } from '../../store'
+import { appendNativeChatDraftNow, type NativeChatDraftAttachment } from './native-chat-draft-cache'
+import {
+  resolveNativeChatAttachmentOwnerForWorktree,
+  type NativeChatAttachmentOwner
+} from './native-chat-attachment-upload'
 import { getStructuredAgentSessionOutbox } from './structured-agent-session-outbox-storage'
-import { appendNativeChatAttachmentCache } from './use-native-chat-composer-attachments'
 
 /**
  * Gives the sender back what a Stop withdrew: its text and images go into this pane's composer,
@@ -15,11 +19,13 @@ import { appendNativeChatAttachmentCache } from './use-native-chat-composer-atta
 function restoreWithdrawnMessages(
   sessionId: string,
   composerScopeKey: string | undefined,
+  composerWorktreeId: string | undefined,
   withdrawn: readonly StructuredAgentSessionOutboxEntry[]
 ): void {
   if (!composerScopeKey || withdrawn.length === 0) {
     return
   }
+  const where = withdrawnImageLocation(composerWorktreeId)
   // What the outbox no longer holds was already given back by whichever view dropped it first.
   const held = new Set(
     getStructuredAgentSessionOutbox(sessionId).map((entry) => entry.clientMessageId)
@@ -29,25 +35,42 @@ function restoreWithdrawnMessages(
       continue
     }
     const blocks = entry.body.blocks
-    appendNativeChatDraftCache(
-      composerScopeKey,
-      blocks.flatMap((block) => (block.type === 'text' ? [block.text] : [])).join('\n')
-    )
-    appendNativeChatAttachmentCache(
-      composerScopeKey,
-      blocks.flatMap((block, index) =>
+    void appendNativeChatDraftNow(composerScopeKey, {
+      text: blocks.flatMap((block) => (block.type === 'text' ? [block.text] : [])).join('\n'),
+      attachments: blocks.flatMap((block, index) =>
         block.type === 'image-ref' && block.path
-          ? [{ id: `withdrawn-${entry.clientMessageId}-${index}`, path: block.path }]
+          ? [{ id: `withdrawn-${entry.clientMessageId}-${index}`, path: block.path, ...where }]
           : []
       )
-    )
+    })
+  }
+}
+
+/** The outbox keeps only an image's path; it lives where this chat's new images do. */
+function withdrawnImageLocation(
+  worktreeId: string | undefined
+): Pick<NativeChatDraftAttachment, 'connectionId' | 'location'> {
+  const owner: NativeChatAttachmentOwner = worktreeId
+    ? resolveNativeChatAttachmentOwnerForWorktree(useAppStore.getState(), worktreeId)
+    : { kind: 'not-ready' }
+  switch (owner.kind) {
+    case 'local':
+      return { location: 'local' }
+    case 'ssh':
+      return { connectionId: owner.connectionId, location: 'ssh' }
+    case 'runtime':
+      return { location: 'runtime' }
+    case 'not-ready':
+      // Left unknown, so the chip is never wrongly marked missing.
+      return {}
   }
 }
 
 export function useStructuredAgentSessionWithdrawnRestore(
   sessionId: string,
   /** Absent where no composer shows this session; the entries are then only dropped. */
-  composerScopeKey: string | undefined
+  composerScopeKey: string | undefined,
+  composerWorktreeId?: string
 ): {
   /** The entries the host settled as withdrawn by a Stop. */
   byHost: (
@@ -73,11 +96,13 @@ export function useStructuredAgentSessionWithdrawnRestore(
         restoreWithdrawnMessages(
           sessionId,
           composerScopeKey,
+          composerWorktreeId,
           entries.filter((entry) => withdrawn.has(entry.clientMessageId))
         )
       },
-      byStop: (entries) => restoreWithdrawnMessages(sessionId, composerScopeKey, entries)
+      byStop: (entries) =>
+        restoreWithdrawnMessages(sessionId, composerScopeKey, composerWorktreeId, entries)
     }),
-    [composerScopeKey, sessionId]
+    [composerScopeKey, composerWorktreeId, sessionId]
   )
 }
diff --git a/src/renderer/src/components/native-chat/structured-session-takeover-report.test.tsx b/src/renderer/src/components/native-chat/structured-session-takeover-report.test.tsx
index b44df6c8304..797985ae709 100644
--- a/src/renderer/src/components/native-chat/structured-session-takeover-report.test.tsx
+++ b/src/renderer/src/components/native-chat/structured-session-takeover-report.test.tsx
@@ -49,6 +49,7 @@ function transport(): NativeChatStructuredComposerTransport {
 function send(structuredTransport: NativeChatStructuredComposerTransport): (text: string) => void {
   const { result } = renderHook(() =>
     useNativeChatStructuredComposerSend({
+      draftKey: 'session:session-test',
       agent: 'claude',
       imageAttachments: [],
       structuredTransport,
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.test.tsx
index 6ae8aca5afe..60967aa53f4 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.test.tsx
@@ -1,12 +1,15 @@
 // @vitest-environment happy-dom
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { act, createElement, useEffect, useRef, useState } from 'react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { act, createElement, useEffect, useLayoutEffect, useRef, useState } from 'react'
 import { createRoot, type Root } from 'react-dom/client'
+import { renderHook } from '@testing-library/react'
 import {
-  clearNativeChatAttachmentCacheForTests,
-  readNativeChatAttachmentCache,
-  useNativeChatComposerAttachments
-} from './use-native-chat-composer-attachments'
+  addNativeChatDraftAttachments,
+  clearNativeChatDraftCacheForTests,
+  readNativeChatDraftAttachments
+} from './native-chat-draft-cache'
+import { useNativeChatComposerAttachments } from './use-native-chat-composer-attachments'
+import { installLocalStorageNativeChatDrafts } from './native-chat-draft-store.test-support'
 import type { NativeChatResolvedTarget } from './native-chat-composer-target'
 import { NATIVE_FILE_DROP_MAX_PATHS } from '../../../../shared/native-file-drop'
 
@@ -129,9 +132,10 @@ async function renderProbe(
 }
 
 describe('useNativeChatComposerAttachments', () => {
+  beforeEach(() => installLocalStorageNativeChatDrafts())
   afterEach(() => {
     runtimeTarget.remote = false
-    clearNativeChatAttachmentCacheForTests()
+    clearNativeChatDraftCacheForTests()
     document.body.replaceChildren()
   })
 
@@ -147,7 +151,7 @@ describe('useNativeChatComposerAttachments', () => {
     expect(first.latest().imageAttachments).toMatchObject([
       { path: '/tmp/orca-native-chat-attach-test.png' }
     ])
-    expect(readNativeChatAttachmentCache('pty-1')).toMatchObject([
+    expect(readNativeChatDraftAttachments('pty-1')).toMatchObject([
       { path: '/tmp/orca-native-chat-attach-test.png' }
     ])
 
@@ -305,6 +309,126 @@ describe('useNativeChatComposerAttachments', () => {
     act(() => probe.root.unmount())
   })
 
+  it('shows every chip in every view of the chat, a pending one included', async () => {
+    const first = await renderProbe('session:chat-1', true)
+    const second = await renderProbe('session:chat-1', true)
+
+    await act(async () => {
+      first.latest().attachResolvedPaths(['/tmp/shared.png'])
+    })
+    act(() => {
+      first.latest().beginPendingImageAttachment('blob:preview-1')
+    })
+    expect(second.latest().imageAttachments).toMatchObject([
+      { path: '/tmp/shared.png' },
+      { pending: true }
+    ])
+
+    const id = second.latest().imageAttachments[0]?.id ?? ''
+    act(() => second.latest().removeImageAttachment(id))
+
+    expect(first.latest().imageAttachments).toMatchObject([{ pending: true }])
+    act(() => first.root.unmount())
+    act(() => second.root.unmount())
+  })
+
+  it("shows chips written between a view's render and its subscription", () => {
+    const { result, unmount } = renderHook(() => {
+      const view = useNativeChatComposerAttachments({
+        attachmentScopeKey: 'session:chat-gap',
+        allowWithoutTarget: true,
+        caret: 0,
+        disabled: false,
+        isComposing: () => false,
+        resolveTarget: () => null,
+        textareaRef: { current: null },
+        setCaret: () => {},
+        setDraft: () => {},
+        setNotice: () => {}
+      })
+      useLayoutEffect(
+        () =>
+          addNativeChatDraftAttachments('session:chat-gap', [{ id: 'late', path: '/late.png' }]),
+        []
+      )
+      return view
+    })
+
+    expect(result.current.imageAttachments).toMatchObject([{ path: '/late.png' }])
+    unmount()
+  })
+
+  it('keeps chips in the order they were added while a paste is still saving', async () => {
+    const probe = await renderProbe('session:chat-order', true)
+    let pastedId: string | null = null
+    act(() => {
+      pastedId = probe.latest().beginPendingImageAttachment('blob:pasted')
+    })
+    await act(async () => {
+      probe.latest().attachResolvedPaths(['/tmp/dropped.png'])
+    })
+    act(() => probe.latest().resolvePendingImageAttachment(pastedId ?? '', '/tmp/pasted.png'))
+
+    expect(probe.latest().imageAttachments.map(({ path }) => path)).toEqual([
+      '/tmp/pasted.png',
+      '/tmp/dropped.png'
+    ])
+    act(() => probe.root.unmount())
+  })
+
+  it('keeps one chip order in every pane and on disk while a paste saves and chips come and go', async () => {
+    const first = await renderProbe('session:chat-race', true)
+    const second = await renderProbe('session:chat-race', true)
+    let pastedId: string | null = null
+    act(() => {
+      pastedId = first.latest().beginPendingImageAttachment('blob:pasted')
+    })
+    await act(async () => {
+      first.latest().attachResolvedPaths(['/tmp/first.png'])
+    })
+    await act(async () => {
+      second.latest().attachResolvedPaths(['/tmp/second.png'])
+    })
+    act(() => first.latest().resolvePendingImageAttachment(pastedId ?? '', '/tmp/pasted.png'))
+    const order = () => ({
+      first: first.latest().imageAttachments.map(({ path }) => path),
+      second: second.latest().imageAttachments.map(({ path }) => path),
+      saved: JSON.parse(
+        localStorage.getItem(
+          `orca:nativeChatComposerDraft:v1:${encodeURIComponent('session:chat-race')}`
+        ) ?? 'null'
+      ).attachments.map(({ path }: { path: string }) => path)
+    })
+
+    const all = ['/tmp/pasted.png', '/tmp/first.png', '/tmp/second.png']
+    expect(order()).toEqual({ first: all, second: all, saved: all })
+    act(() => second.latest().removeImageAttachment(first.latest().imageAttachments[1]!.id))
+    const rest = ['/tmp/pasted.png', '/tmp/second.png']
+    expect(order()).toEqual({ first: rest, second: rest, saved: rest })
+    act(() => first.root.unmount())
+    act(() => second.root.unmount())
+  })
+
+  it('keeps both chips when two views attach in the same millisecond', async () => {
+    const now = vi.spyOn(Date, 'now').mockReturnValue(1_000)
+    const first = await renderProbe('session:chat-same-ms', true)
+    const second = await renderProbe('session:chat-same-ms', true)
+    await act(async () => {
+      first.latest().attachResolvedPaths(['/tmp/first.png'])
+    })
+    await act(async () => {
+      second.latest().attachResolvedPaths(['/tmp/second.png'])
+    })
+    now.mockRestore()
+
+    expect(first.latest().imageAttachments.map(({ path }) => path)).toEqual([
+      '/tmp/first.png',
+      '/tmp/second.png'
+    ])
+    act(() => first.root.unmount())
+    act(() => second.root.unmount())
+  })
+
   it('removes an attached image chip cleanly', async () => {
     const probe = await renderProbe('pty-1')
     await act(async () => {
@@ -316,7 +440,7 @@ describe('useNativeChatComposerAttachments', () => {
       probe.latest().removeImageAttachment(id as string)
     })
     expect(probe.latest().imageAttachments).toMatchObject([])
-    expect(readNativeChatAttachmentCache('pty-1')).toMatchObject([])
+    expect(readNativeChatDraftAttachments('pty-1')).toMatchObject([])
     act(() => probe.root.unmount())
   })
 
@@ -440,8 +564,9 @@ describe('useNativeChatComposerAttachments', () => {
     act(() => probe.root.unmount())
   })
 
-  it('excludes a pending chip from the scope cache while a settled chip persists', async () => {
+  it('keeps a pending chip off disk and its preview in the pane that pasted it', async () => {
     const probe = await renderProbe('pty-1')
+    const other = await renderProbe('pty-1')
     let pendingId: string | null = null
     act(() => {
       pendingId = probe.latest().beginPendingImageAttachment('blob:preview-1')
@@ -449,12 +574,40 @@ describe('useNativeChatComposerAttachments', () => {
     await act(async () => {
       probe.latest().attachResolvedPaths(['/tmp/settled.png'])
     })
+    act(() => window.dispatchEvent(new Event('pagehide')))
 
-    const cached = readNativeChatAttachmentCache('pty-1')
-    expect(cached.some((attachment) => attachment.id === pendingId)).toBe(false)
-    expect(cached).toMatchObject([{ path: '/tmp/settled.png' }])
-    expect(cached[0]?.previewUrl).toBeUndefined()
+    const saved = JSON.parse(
+      localStorage.getItem(`orca:nativeChatComposerDraft:v1:${encodeURIComponent('pty-1')}`) ??
+        'null'
+    )
+    expect(saved?.attachments).toEqual([
+      { id: expect.any(String), path: '/tmp/settled.png', location: 'local' }
+    ])
+    expect(probe.latest().imageAttachments).toContainEqual(
+      expect.objectContaining({ id: pendingId, previewUrl: 'blob:preview-1', pending: true })
+    )
+    expect(other.latest().imageAttachments[0]).not.toHaveProperty('previewUrl')
     act(() => probe.root.unmount())
+    act(() => other.root.unmount())
+  })
+
+  // Once the pasting pane is gone nothing else holds the URL, so a later remove could not free it.
+  it("revokes a pane's blob previews when it unmounts, though its chips stay in the chat", async () => {
+    const revoke = vi.spyOn(URL, 'revokeObjectURL')
+    const pasting = await renderProbe('session:chat-unmount', true)
+    let id: string | null = null
+    act(() => {
+      id = pasting.latest().beginPendingImageAttachment('blob:pasted')
+    })
+    act(() => pasting.latest().resolvePendingImageAttachment(id ?? '', '/tmp/pasted.png'))
+
+    act(() => pasting.root.unmount())
+
+    expect(revoke).toHaveBeenCalledWith('blob:pasted')
+    expect(readNativeChatDraftAttachments('session:chat-unmount')).toMatchObject([
+      { path: '/tmp/pasted.png' }
+    ])
+    revoke.mockRestore()
   })
 
   it('revokes a blob: preview URL on removal but not a data: preview URL', async () => {
@@ -482,3 +635,92 @@ describe('useNativeChatComposerAttachments', () => {
     act(() => probe.root.unmount())
   })
 })
+
+describe('a restored draft whose image is gone', () => {
+  afterEach(() => {
+    clearNativeChatDraftCacheForTests()
+    document.body.replaceChildren()
+  })
+
+  it('marks only a chip whose file is proven gone, checking each restored chip once', async () => {
+    const pathsExist = vi.fn(
+      async ({ filePaths, connectionId }: { filePaths: string[]; connectionId?: string }) =>
+        // An unreachable host cannot say; that is not proof the file is gone.
+        filePaths.map((path) =>
+          connectionId ? { error: 'offline' } : { exists: path !== '/gone.png' }
+        )
+    )
+    Object.defineProperty(window, 'api', { configurable: true, value: { fs: { pathsExist } } })
+    addNativeChatDraftAttachments('session:restored', [
+      { id: 'gone', path: '/gone.png', location: 'local' },
+      { id: 'here', path: '/here.png', location: 'local' },
+      { id: 'remote', path: '/remote.png', connectionId: 'ssh-1', location: 'ssh' },
+      // A runtime server's path, or one saved before locations were recorded, means nothing here.
+      { id: 'runtime', path: '/srv/gone.png', location: 'runtime' },
+      { id: 'unknown', path: '/old/gone.png' }
+    ])
+
+    const probe = await renderProbe('session:restored', true)
+    await act(async () => {})
+    await act(async () => {
+      probe.latest().attachResolvedPaths(['/new.png'])
+    })
+
+    expect(
+      probe.latest().imageAttachments.map(({ path, missing }) => [path, missing === true])
+    ).toEqual([
+      ['/gone.png', true],
+      ['/here.png', false],
+      ['/remote.png', false],
+      ['/srv/gone.png', false],
+      ['/old/gone.png', false],
+      ['/new.png', false]
+    ])
+    expect(pathsExist).toHaveBeenCalledTimes(2)
+    expect(pathsExist).toHaveBeenCalledWith({ filePaths: ['/gone.png', '/here.png'] })
+    expect(pathsExist).toHaveBeenCalledWith({ filePaths: ['/remote.png'], connectionId: 'ssh-1' })
+    expect(readNativeChatDraftAttachments('session:restored')[0]).toEqual({
+      id: 'gone',
+      path: '/gone.png',
+      location: 'local'
+    })
+    act(() => probe.root.unmount())
+  })
+
+  // The read grant made at attach lived in memory; without it a restored preview is blank and a
+  // deleted original can never be shown missing.
+  it('grants each restored local image before checking it, and holds its preview until then', async () => {
+    const calls: string[] = []
+    const answer = Promise.withResolvers<void>()
+    const authorizeExternalPath = vi.fn(async ({ targetPath }: { targetPath: string }) => {
+      calls.push(`grant ${targetPath}`)
+    })
+    const pathsExist = vi.fn(async ({ filePaths }: { filePaths: string[] }) => {
+      calls.push(`check ${filePaths.join(',')}`)
+      await answer.promise
+      return filePaths.map(() => ({ exists: true }))
+    })
+    Object.defineProperty(window, 'api', {
+      configurable: true,
+      value: { fs: { authorizeExternalPath, pathsExist } }
+    })
+    addNativeChatDraftAttachments('session:granted', [
+      { id: 'local', path: '/Users/me/Desktop/shot.png', location: 'local' },
+      { id: 'remote', path: '/remote.png', connectionId: 'ssh-1' }
+    ])
+
+    const probe = await renderProbe('session:granted', true)
+    const checking = () => probe.latest().imageAttachments.map((chip) => chip.checking === true)
+    expect(checking()).toEqual([true, true])
+    await act(async () => answer.resolve())
+
+    expect(authorizeExternalPath.mock.calls).toEqual([
+      [{ targetPath: '/Users/me/Desktop/shot.png' }]
+    ])
+    expect(calls.indexOf('grant /Users/me/Desktop/shot.png')).toBeLessThan(
+      calls.indexOf('check /Users/me/Desktop/shot.png')
+    )
+    expect(checking()).toEqual([false, false])
+    act(() => probe.root.unmount())
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts b/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts
index 341e242901f..607525e7d70 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-attachments.ts
@@ -1,13 +1,23 @@
 import type { NativeChatComposerInput } from './native-chat-composer-input'
-import { useCallback, useEffect, useRef, useState, type RefObject } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState, type RefObject } from 'react'
 import { translate } from '@/i18n/i18n'
+import { createBrowserUuid } from '@/lib/browser-uuid'
 import {
   nativeChatComposerTargetIsRemote,
   type NativeChatResolvedTarget
 } from './native-chat-composer-target'
 import type { NativeChatComposerImageAttachment } from './NativeChatComposerField'
-import { setBoundedScopeCacheEntry } from './native-chat-composer-scope-cache'
+import {
+  addNativeChatDraftAttachments,
+  clearNativeChatDraftAttachments,
+  readNativeChatDraftAttachments,
+  removeNativeChatDraftAttachment,
+  settleNativeChatDraftAttachment,
+  subscribeToNativeChatDraft,
+  type NativeChatDraftChip
+} from './native-chat-draft-cache'
 import type { NativeChatResolvedPathOptions } from './native-chat-resolved-path-ownership'
+import { findMissingNativeChatAttachments } from './native-chat-attachment-existence'
 import { useNativeChatResolvedPathAttachments } from './use-native-chat-resolved-path-attachments'
 
 export type UseNativeChatComposerAttachmentsArgs = {
@@ -48,38 +58,61 @@ export function useNativeChatComposerAttachments({
   resolvePendingImageAttachment: (id: string, path: string, connectionId?: string | null) => void
   dropPendingImageAttachment: (id: string) => void
 } {
-  const [imageAttachments, setImageAttachments] = useState<NativeChatComposerImageAttachment[]>(
-    () => readNativeChatAttachmentCache(attachmentScopeKey)
-  )
-  const imageAttachmentCounter = useRef(0)
-
-  useEffect(
-    () =>
-      subscribeToNativeChatAttachmentAppend(attachmentScopeKey, (appended) =>
-        setImageAttachments((prev) => [...prev, ...appended])
-      ),
-    [attachmentScopeKey]
-  )
-
-  const updateImageAttachments = useCallback(
-    (
-      updater: (
-        previous: NativeChatComposerImageAttachment[]
-      ) => NativeChatComposerImageAttachment[]
-    ) => {
-      setImageAttachments((prev) => {
-        const next = updater(prev)
-        writeNativeChatAttachmentCache(attachmentScopeKey, next)
-        return next
-      })
-    },
-    [attachmentScopeKey]
-  )
+  // Clipboard thumbnails of chips pasted in this view; the chips themselves are the chat's.
+  const previewsRef = useRef(new Map<string, string>())
+  const [shared, setShared] = useState(() => readNativeChatDraftAttachments(attachmentScopeKey))
+  // Chips this view has checked or attached itself; anything else may be restored from disk.
+  const checkedIdsRef = useRef(new Set<string>())
+  const [missingIds, setMissingIds] = useState<ReadonlySet<string>>(() => new Set())
+  // Restored chips whose read grant and check are still running; their previews wait for both.
+  const [checkingIds, setCheckingIds] = useState<ReadonlySet<string>>(() => new Set())
+
+  // A saved draft can outlive its image (age sweep, OS temp cleanup), so each restored chip is
+  // checked once; a missing one is shown as such and blocks Send, rather than sending a dead path.
+  useEffect(() => {
+    const unchecked = shared.filter(
+      (attachment) => !attachment.pending && !checkedIdsRef.current.has(attachment.id)
+    )
+    if (unchecked.length === 0) {
+      return
+    }
+    const ids = new Set(unchecked.map((attachment) => attachment.id))
+    ids.forEach((id) => checkedIdsRef.current.add(id))
+    setCheckingIds((previous) => new Set([...previous, ...ids]))
+    void findMissingNativeChatAttachments(unchecked).then((missing) => {
+      if (missing.size > 0) {
+        setMissingIds((previous) => new Set([...previous, ...missing]))
+      }
+      setCheckingIds((previous) => new Set([...previous].filter((id) => !ids.has(id))))
+    })
+  }, [shared])
+
+  useEffect(() => {
+    const previews = previewsRef.current
+    const showShared = (): void => {
+      const next = readNativeChatDraftAttachments(attachmentScopeKey)
+      const ids = new Set(next.map((chip) => chip.id))
+      for (const [id, previewUrl] of previews) {
+        if (!ids.has(id)) {
+          releasePreviewUrl(previewUrl)
+          previews.delete(id)
+        }
+      }
+      setShared(next)
+    }
+    const unsubscribe = subscribeToNativeChatDraft(attachmentScopeKey, showShared)
+    // A write between this view's render and its subscription would otherwise never show here.
+    showShared()
+    return () => {
+      unsubscribe()
+      // Previews die with the view that holds them; other views read the chip from its path.
+      previews.forEach(releasePreviewUrl)
+      previews.clear()
+    }
+  }, [attachmentScopeKey])
 
-  const nextAttachmentId = useCallback((): string => {
-    imageAttachmentCounter.current += 1
-    return `${Date.now()}-${imageAttachmentCounter.current}`
-  }, [])
+  // Every view of the chat attaches into one list, so ids must not repeat across views.
+  const nextAttachmentId = useCallback((): string => createBrowserUuid(), [])
 
   // Client-local paths cannot cross into a runtime target; workspace-owned
   // paths may only bypass this after the internal drop ownership gate.
@@ -104,20 +137,17 @@ export function useNativeChatComposerAttachments({
   }, [setNotice])
 
   const appendImageAttachments = useCallback(
-    (paths: { path: string; connectionId?: string | null }[]) => {
+    (paths: { path: string; connectionId?: string | null; onRuntimeHost?: boolean }[]) => {
       if (paths.length === 0) {
         return
       }
-      updateImageAttachments((prev) => [
-        ...prev,
-        ...paths.map(({ path, connectionId }) => ({
-          id: nextAttachmentId(),
-          path,
-          connectionId: connectionId ?? undefined
-        }))
-      ])
+      const attached = paths.map(({ path, connectionId, onRuntimeHost }) =>
+        settledChip(nextAttachmentId(), path, connectionId, onRuntimeHost)
+      )
+      attached.forEach(({ id }) => checkedIdsRef.current.add(id))
+      addNativeChatDraftAttachments(attachmentScopeKey, attached)
     },
-    [nextAttachmentId, updateImageAttachments]
+    [attachmentScopeKey, nextAttachmentId]
   )
 
   const { attachResolvedPaths, disabledRef, flushPendingAttachments } =
@@ -146,141 +176,75 @@ export function useNativeChatComposerAttachments({
         return null
       }
       const id = nextAttachmentId()
-      updateImageAttachments((prev) => [...prev, { id, path: '', previewUrl, pending: true }])
+      if (previewUrl) {
+        previewsRef.current.set(id, previewUrl)
+      }
+      addNativeChatDraftAttachments(attachmentScopeKey, [{ id, path: '', pending: true }])
       return id
     },
     [
+      attachmentScopeKey,
       attachmentTargetBlocked,
       disabledRef,
       nextAttachmentId,
-      noteAttachmentTargetBlocked,
-      updateImageAttachments
+      noteAttachmentTargetBlocked
     ]
   )
 
   const resolvePendingImageAttachment = useCallback(
     (id: string, path: string, connectionId?: string | null) => {
-      updateImageAttachments((prev) =>
-        prev.map((attachment) =>
-          attachment.id === id
-            ? {
-                ...attachment,
-                path,
-                connectionId: connectionId ?? undefined,
-                pending: undefined
-              }
-            : attachment
-        )
-      )
+      checkedIdsRef.current.add(id)
+      settleNativeChatDraftAttachment(attachmentScopeKey, settledChip(id, path, connectionId))
     },
-    [updateImageAttachments]
+    [attachmentScopeKey]
   )
 
-  const dropPendingImageAttachment = useCallback(
-    (id: string) => {
-      updateImageAttachments((prev) => removeAttachmentById(prev, id))
-    },
-    [updateImageAttachments]
+  const removeImageAttachment = useCallback(
+    (id: string) => removeNativeChatDraftAttachment(attachmentScopeKey, id),
+    [attachmentScopeKey]
+  )
+
+  const imageAttachments = useMemo(
+    () =>
+      shared.map((chip): NativeChatComposerImageAttachment => {
+        const previewUrl = previewsRef.current.get(chip.id)
+        return {
+          ...chip,
+          ...(previewUrl ? { previewUrl } : {}),
+          ...(missingIds.has(chip.id) ? { missing: true } : {}),
+          ...(checkingIds.has(chip.id) ? { checking: true } : {})
+        }
+      }),
+    [checkingIds, missingIds, shared]
   )
 
   return {
     imageAttachments,
     attachResolvedPaths,
-    clearImageAttachments: () =>
-      updateImageAttachments((prev) => {
-        prev.forEach(releaseAttachmentPreview)
-        return []
-      }),
+    clearImageAttachments: () => clearNativeChatDraftAttachments(attachmentScopeKey),
     flushPendingAttachments,
-    removeImageAttachment: (id) => updateImageAttachments((prev) => removeAttachmentById(prev, id)),
+    removeImageAttachment,
     beginPendingImageAttachment,
     resolvePendingImageAttachment,
-    dropPendingImageAttachment
-  }
-}
-
-/** Object URLs minted from a clipboard blob leak until revoked; data URLs don't. */
-function releaseAttachmentPreview(attachment: NativeChatComposerImageAttachment): void {
-  if (attachment.previewUrl?.startsWith('blob:')) {
-    URL.revokeObjectURL(attachment.previewUrl)
+    dropPendingImageAttachment: removeImageAttachment
   }
 }
 
-function removeAttachmentById(
-  attachments: readonly NativeChatComposerImageAttachment[],
-  id: string
-): NativeChatComposerImageAttachment[] {
-  const removed = attachments.find((attachment) => attachment.id === id)
-  if (removed) {
-    releaseAttachmentPreview(removed)
+function settledChip(
+  id: string,
+  path: string,
+  connectionId?: string | null,
+  onRuntimeHost = false
+): NativeChatDraftChip {
+  if (connectionId) {
+    return { id, path, connectionId, location: 'ssh' }
   }
-  return attachments.filter((attachment) => attachment.id !== id)
-}
-
-const attachmentCache = new Map<string, NativeChatComposerImageAttachment[]>()
-
-export function readNativeChatAttachmentCache(
-  scopeKey: string
-): NativeChatComposerImageAttachment[] {
-  return [...(attachmentCache.get(scopeKey) ?? [])]
+  return { id, path, location: onRuntimeHost ? 'runtime' : 'local' }
 }
 
-function writeNativeChatAttachmentCache(
-  scopeKey: string,
-  cacheable: readonly NativeChatComposerImageAttachment[]
-): void {
-  // A pending chip's save resolves into THIS hook instance; restoring one into a
-  // remount would strand it pending forever, so only settled chips are cached.
-  const attachments = cacheable
-    .filter((attachment) => !attachment.pending)
-    // Preview URLs can retain the full clipboard Blob (or a large data URL) for
-    // the lifetime of the scope cache. Settled attachments reload from their
-    // authorized path after a remount, so never retain the transient preview.
-    .map(({ previewUrl: _previewUrl, ...attachment }) => attachment)
-  if (attachments.length === 0) {
-    attachmentCache.delete(scopeKey)
-    return
-  }
-  // LRU-bounded so pending attachments for permanently-removed panes can't accumulate.
-  setBoundedScopeCacheEntry(attachmentCache, scopeKey, [...attachments])
-}
-
-// Only a write from outside the composer notifies; its own writes already hold the chips.
-const appendListeners = new Map<
-  string,
-  Set<(appended: readonly NativeChatComposerImageAttachment[]) => void>
->()
-
-/** Puts settled images back after whatever is attached, and shows them in a mounted composer. */
-export function appendNativeChatAttachmentCache(
-  scopeKey: string,
-  appended: readonly NativeChatComposerImageAttachment[]
-): void {
-  if (appended.length === 0) {
-    return
-  }
-  writeNativeChatAttachmentCache(scopeKey, [
-    ...readNativeChatAttachmentCache(scopeKey),
-    ...appended
-  ])
-  appendListeners.get(scopeKey)?.forEach((listener) => listener(appended))
-}
-
-function subscribeToNativeChatAttachmentAppend(
-  scopeKey: string,
-  listener: (appended: readonly NativeChatComposerImageAttachment[]) => void
-): () => void {
-  const listeners = appendListeners.get(scopeKey) ?? new Set()
-  appendListeners.set(scopeKey, listeners)
-  listeners.add(listener)
-  return () => {
-    listeners.delete(listener)
-    if (listeners.size === 0 && appendListeners.get(scopeKey) === listeners) {
-      appendListeners.delete(scopeKey)
-    }
+/** Object URLs minted from a clipboard blob leak until revoked; data URLs don't. */
+function releasePreviewUrl(previewUrl: string): void {
+  if (previewUrl.startsWith('blob:')) {
+    URL.revokeObjectURL(previewUrl)
   }
 }
-
-export function clearNativeChatAttachmentCacheForTests(): void {
-  attachmentCache.clear()
-}
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-paste.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-composer-paste.test.tsx
index 44c1f59c3c3..c749e7330a3 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-paste.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-paste.test.tsx
@@ -281,7 +281,10 @@ describe('useNativeChatComposerPaste', () => {
     await act(async () => {
       probe.latest().handlePaste(imagePasteEvent())
     })
-    expect(mocks.saveClipboardImageAsTempFile).toHaveBeenCalledWith({ connectionId: 'conn-1' })
+    // The remote host keeps it; the chat storage flag is for local pastes only.
+    expect(mocks.saveClipboardImageAsTempFile).toHaveBeenCalledExactlyOnceWith({
+      connectionId: 'conn-1'
+    })
     expect(store.chips).toEqual([
       {
         id: 'chip-1',
@@ -393,6 +396,8 @@ describe('useNativeChatComposerPaste', () => {
     })
     expect(store.chips).toHaveLength(0)
     expect(attachResolvedPaths).toHaveBeenCalledWith(['C:\\Temp\\orca-paste-3.png'], null)
+    // A draft can hold a local paste across a reboot, so it goes to Orca's own storage.
+    expect(mocks.saveClipboardImageAsTempFile).toHaveBeenCalledWith({ chatAttachment: true })
   })
 
   it('inserts text independently of a failed image save', async () => {
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-paste.ts b/src/renderer/src/components/native-chat/use-native-chat-composer-paste.ts
index 6899ee76905..c669d19899a 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-paste.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-paste.ts
@@ -104,7 +104,7 @@ export function useNativeChatComposerPaste({
         // SSH panes save the image on the remote host (SFTP) so the attached
         // path is readable by the remote agent, matching terminal image paste.
         const tempPath = await window.api.ui.saveClipboardImageAsTempFile(
-          owner.kind === 'ssh' ? { connectionId: owner.connectionId } : undefined
+          owner.kind === 'ssh' ? { connectionId: owner.connectionId } : { chatAttachment: true }
         )
         return tempPath ? { status: 'saved', tempPath } : { status: 'empty' }
       } catch (error) {
diff --git a/src/renderer/src/components/native-chat/use-native-chat-composer-submit.ts b/src/renderer/src/components/native-chat/use-native-chat-composer-submit.ts
index 7bf8ea7f870..e7dee2c8293 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-composer-submit.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-composer-submit.ts
@@ -108,7 +108,7 @@ export function useNativeChatComposerSubmit(args: {
   ])
 
   const send = useCallback(() => {
-    if (imageAttachments.some((attachment) => attachment.pending)) {
+    if (imageAttachments.some((attachment) => attachment.pending || attachment.missing)) {
       return
     }
     if (threadGoal && structuredTransport && isBareStructuredAgentSessionGoalCommand(draft)) {
diff --git a/src/renderer/src/components/native-chat/use-native-chat-draft.ts b/src/renderer/src/components/native-chat/use-native-chat-draft.ts
index 5653c0a77a8..3268780a378 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-draft.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-draft.ts
@@ -1,82 +1,110 @@
-import { useCallback, useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react'
 import {
   appendNativeChatDraftText,
   readNativeChatDraftCache,
+  subscribeToNativeChatDraft,
   subscribeToNativeChatDraftAppend,
   writeNativeChatDraftCache
 } from './native-chat-draft-cache'
 
 /**
- * Composer draft state backed by the scope cache so a typed-but-unsent message
- * survives the composer unmounting on a TUI/GUI toggle. `scopeKey` is the stable
- * pane key also used for image attachments; when it changes (the composer is
- * reused for a different pane) the cached draft is reloaded.
+ * Composer draft state for one view of a chat. `draftKey` names the chat (`nativeChatDraftKey`);
+ * every view of it shares one draft, so what is typed here shows in the others and survives the
+ * composer unmounting or Orca quitting. While this view's IME composes, the live composition
+ * owns the field: other writers' text waits until it settles, as every programmatic draft does,
+ * and the composition reaches the chat only once it settles.
  */
 export function useNativeChatDraft(
-  scopeKey: string,
+  draftKey: string,
   isComposing: () => boolean
 ): {
   draft: string
   setDraft: (next: string | ((previous: string) => string)) => void
-  /** Shows text appended during an IME composition, which owns the field until it settles. */
+  /** Settles the draft after an IME composition: shows text appended meanwhile. */
   flushDraftAppends: () => void
 } {
-  const [draft, setDraftState] = useState(() => readNativeChatDraftCache(scopeKey))
-  // Appended while composing: the editor's own writes would erase it, so the cache keeps it after them.
-  const pendingAppendRef = useRef<{ scopeKey: string; text: string } | null>(null)
+  const [draft, setDraftState] = useState(() => readNativeChatDraftCache(draftKey))
+  // This view's draft for synchronous updates; React state only renders it.
+  const draftRef = useRef(draft)
+  // Appended while composing; settling (or a clear meanwhile) writes it after this view's text.
+  const pendingAppendRef = useRef<{ draftKey: string; text: string } | null>(null)
 
-  // Reload the cached draft when reused for a different pane (scope change),
-  // adjusting state during render rather than in an effect so the restored draft
-  // is visible on the first paint after the switch.
-  const lastScopeKey = useRef(scopeKey)
-  if (lastScopeKey.current !== scopeKey) {
-    lastScopeKey.current = scopeKey
-    setDraftState(readNativeChatDraftCache(scopeKey))
+  const showDraft = useCallback((next: string) => {
+    draftRef.current = next
+    setDraftState(next)
+  }, [])
+
+  // Reload when reused for a different chat, during render so the first paint is right.
+  const [shownKey, setShownKey] = useState(draftKey)
+  if (shownKey !== draftKey) {
+    setShownKey(draftKey)
+    setDraftState(readNativeChatDraftCache(draftKey))
   }
+  useLayoutEffect(() => {
+    draftRef.current = draft
+  }, [draft])
 
-  useEffect(
-    () =>
-      subscribeToNativeChatDraftAppend(scopeKey, (text) => {
-        if (!isComposing()) {
-          setDraftState(readNativeChatDraftCache(scopeKey))
-          return
-        }
-        const pending = pendingAppendRef.current
-        pendingAppendRef.current = {
-          scopeKey,
-          text:
-            pending?.scopeKey === scopeKey ? appendNativeChatDraftText(pending.text, text) : text
-        }
-      }),
-    [isComposing, scopeKey]
-  )
+  useEffect(() => {
+    // This view's own writes come back too; they hold what it already shows.
+    const showShared = (): void => {
+      const shared = readNativeChatDraftCache(draftKey)
+      // A clear still reaches a composing field, which keeps only the composed segment.
+      if (!isComposing() || shared === '') {
+        showDraft(shared)
+      }
+    }
+    const unsubscribeChange = subscribeToNativeChatDraft(draftKey, showShared)
+    const unsubscribeAppend = subscribeToNativeChatDraftAppend(draftKey, (text) => {
+      if (!isComposing()) {
+        return
+      }
+      const pending = pendingAppendRef.current
+      pendingAppendRef.current = {
+        draftKey,
+        text: pending?.draftKey === draftKey ? appendNativeChatDraftText(pending.text, text) : text
+      }
+    })
+    // A write between this view's render and its subscription would otherwise never show here.
+    showShared()
+    return () => {
+      unsubscribeChange()
+      unsubscribeAppend()
+    }
+  }, [draftKey, isComposing, showDraft])
 
-  // Persist every mutation through the cache. Accepts the same value/updater
-  // forms as a useState setter so call sites are drop-in.
+  // Accepts the same value/updater forms as a useState setter so call sites are drop-in.
   const setDraft = useCallback(
     (next: string | ((previous: string) => string)) => {
-      setDraftState((previous) => {
-        const resolved = typeof next === 'function' ? next(previous) : next
+      const resolved = typeof next === 'function' ? next(draftRef.current) : next
+      // A composition's keystrokes stay in this view until it settles, so a box still holding
+      // text another view cleared never writes it back. A clear itself is written at once.
+      if (!isComposing() || resolved === '') {
         const pending = pendingAppendRef.current
         writeNativeChatDraftCache(
-          scopeKey,
-          pending?.scopeKey === scopeKey
+          draftKey,
+          pending?.draftKey === draftKey
             ? appendNativeChatDraftText(resolved, pending.text)
-            : resolved
+            : resolved,
+          resolved === '' ? 'now' : 'after-pause'
         )
-        return resolved
-      })
+      }
+      showDraft(resolved)
     },
-    [scopeKey]
+    [draftKey, isComposing, showDraft]
   )
 
   const flushDraftAppends = useCallback(() => {
     const pending = pendingAppendRef.current
     pendingAppendRef.current = null
-    if (pending?.scopeKey === scopeKey) {
+    if (pending?.draftKey === draftKey) {
       setDraft((previous) => appendNativeChatDraftText(previous, pending.text))
+      return
+    }
+    // Another view wrote while this one composed; the settled composition is the newer intent.
+    if (draftRef.current !== readNativeChatDraftCache(draftKey)) {
+      setDraft(draftRef.current)
     }
-  }, [scopeKey, setDraft])
+  }, [draftKey, setDraft])
 
   return { draft, setDraft, flushDraftAppends }
 }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-held-sends.ts b/src/renderer/src/components/native-chat/use-native-chat-held-sends.ts
new file mode 100644
index 00000000000..20d9bbd2044
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-native-chat-held-sends.ts
@@ -0,0 +1,41 @@
+import { useEffect, useMemo } from 'react'
+import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import type { AgentSessionQueuedMessage } from '../../../../shared/agent-session-queued-message-wire'
+import {
+  releaseNativeChatHeldSendsTheHostHolds,
+  settleRestoredNativeChatHeldSends
+} from './native-chat-held-sends'
+import {
+  structuredAgentSessionHostHoldsMessage,
+  type StructuredAgentSessionHostCopies
+} from './structured-agent-session-message-delivery'
+
+const NO_CARDS: readonly AgentSessionQueuedMessage[] = []
+
+/**
+ * Keeps the chat's held sends in step with its journal: each one the host holds is dropped, and
+ * once the journal first answers after a relaunch, the earlier run's others go back into the box.
+ */
+export function useNativeChatHeldSends(
+  draftKey: string | undefined,
+  journal: {
+    status: 'idle' | 'loading' | 'ready' | 'error'
+    submissions: readonly AgentJournalSubmission[]
+    queuedMessages?: readonly AgentSessionQueuedMessage[] | null
+  }
+): void {
+  const { status, submissions, queuedMessages } = journal
+  const host = useMemo(
+    (): StructuredAgentSessionHostCopies => ({ submissions, cards: queuedMessages ?? NO_CARDS }),
+    [queuedMessages, submissions]
+  )
+  useEffect(() => {
+    if (!draftKey || (status !== 'ready' && status !== 'error')) {
+      return
+    }
+    const hostHolds = (clientMessageId: string): boolean =>
+      status === 'ready' && structuredAgentSessionHostHoldsMessage(host, clientMessageId)
+    settleRestoredNativeChatHeldSends(draftKey, hostHolds)
+    releaseNativeChatHeldSendsTheHostHolds(draftKey, hostHolds)
+  }, [draftKey, host, status])
+}
diff --git a/src/renderer/src/components/native-chat/use-native-chat-launch-draft-adoption.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-launch-draft-adoption.test.tsx
index 71da8b11b60..4ea54f19502 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-launch-draft-adoption.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-launch-draft-adoption.test.tsx
@@ -1,6 +1,7 @@
 // @vitest-environment happy-dom
 
-import { renderHook } from '@testing-library/react'
+import { act, cleanup, renderHook } from '@testing-library/react'
+import { installLocalStorageNativeChatDrafts } from './native-chat-draft-store.test-support'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { NativeChatLaunchDraft } from '@/lib/native-chat-launch-prompt'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
@@ -12,6 +13,7 @@ import {
 const mocks = vi.hoisted(() => ({
   markNativeChatLaunchDraftAdopted: vi.fn(),
   clearNativeChatLaunchDraft: vi.fn(),
+  seedNativeChatLaunchDraft: vi.fn(),
   storeState: { nativeChatLaunchDraftByTabId: {} as Record<string, NativeChatLaunchDraft> }
 }))
 
@@ -24,7 +26,8 @@ vi.mock('../../store', () => {
   useAppStore.getState = () => ({
     ...mocks.storeState,
     markNativeChatLaunchDraftAdopted: mocks.markNativeChatLaunchDraftAdopted,
-    clearNativeChatLaunchDraft: mocks.clearNativeChatLaunchDraft
+    clearNativeChatLaunchDraft: mocks.clearNativeChatLaunchDraft,
+    seedNativeChatLaunchDraft: mocks.seedNativeChatLaunchDraft
   })
   return { useAppStore }
 })
@@ -54,12 +57,15 @@ function setup(args: {
     useNativeChatLaunchDraftAdoption({
       terminalTabId: 'tab-1',
       agent: args.agent ?? 'claude',
-      launchDraft: args.launchDraft,
-      launchDraftResolved: args.launchDraftResolved ?? false,
+      launchSeed: {
+        launchDraft: args.launchDraft,
+        launchDraftResolved: args.launchDraftResolved ?? false,
+        ownsTabWideLaunchDraft: args.ownsTabWideLaunchDraft ?? true
+      },
+      tuiDraftKey: undefined,
       draft: args.draft ?? '',
       setDraft,
-      setCaret,
-      ownsTabWideLaunchDraft: args.ownsTabWideLaunchDraft ?? true
+      setCaret
     })
   )
   return { setDraft, setCaret }
@@ -322,12 +328,11 @@ describe('launch draft adoption across a split', () => {
       useNativeChatLaunchDraftAdoption({
         terminalTabId: 'tab-1',
         agent: 'claude',
-        launchDraft: signal.launchDraft,
-        launchDraftResolved: signal.launchDraftResolved,
+        launchSeed: { ...signal, ownsTabWideLaunchDraft: args.ownsTabWideLaunchDraft },
+        tuiDraftKey: undefined,
         draft: args.draft ?? '',
         setDraft,
-        setCaret,
-        ownsTabWideLaunchDraft: args.ownsTabWideLaunchDraft
+        setCaret
       })
     })
     return { setDraft, setCaret }
@@ -375,3 +380,90 @@ describe('launch draft adoption across a split', () => {
     expect(mocks.clearNativeChatLaunchDraft).toHaveBeenCalledWith('tab-1')
   })
 })
+
+describe('a launch draft saved with its chat', () => {
+  /** A fresh renderer: module memory is gone, only localStorage remains. */
+  async function relaunch() {
+    cleanup()
+    vi.resetModules()
+    return {
+      draft: await import('./use-native-chat-draft'),
+      adoption: await import('./use-native-chat-launch-draft-adoption'),
+      cache: await import('./native-chat-draft-cache')
+    }
+  }
+
+  function renderComposer(
+    modules: Awaited<ReturnType<typeof relaunch>>,
+    draftKey: string,
+    seed: NativeChatLaunchDraft | null,
+    tuiDraftKey: string | undefined
+  ) {
+    return renderHook(() => {
+      const view = modules.draft.useNativeChatDraft(draftKey, () => false)
+      modules.adoption.useNativeChatLaunchDraftAdoption({
+        terminalTabId: 'tab-1',
+        agent: 'claude',
+        launchSeed: { launchDraft: seed, launchDraftResolved: false, ownsTabWideLaunchDraft: true },
+        tuiDraftKey,
+        draft: view.draft,
+        setDraft: view.setDraft,
+        setCaret: () => {}
+      })
+      return view
+    })
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    localStorage.clear()
+    installLocalStorageNativeChatDrafts()
+    mocks.storeState.nativeChatLaunchDraftByTabId = {}
+  })
+
+  // A structured chat has no input line holding the prompt, so the draft is its only copy.
+  it("keeps a structured chat's launch prompt across a relaunch", async () => {
+    const before = await relaunch()
+    renderComposer(before, 'session:s1', launchDraft(), undefined)
+    act(() => window.dispatchEvent(new Event('pagehide')))
+
+    const after = await relaunch()
+
+    expect(after.cache.readNativeChatDraftCache('session:s1')).toBe(SEED_TEXT)
+    expect(after.cache.readNativeChatDraftTuiInputSeed('session:s1')).toBeUndefined()
+  })
+
+  // The agent's input line still holds the seed after a relaunch; the send must replace it.
+  it('re-seeds an edited multi-line terminal seed after a relaunch, so the send replaces it', async () => {
+    const seeded = 'line one\nline two\nline three'
+    const before = await relaunch()
+    const { result } = renderComposer(
+      before,
+      'pane:tab-1:leaf',
+      launchDraft({ text: seeded, createdAt: SEEDED_AT }),
+      'pane:tab-1:leaf'
+    )
+    act(() => result.current.setDraft(`${seeded} edited`))
+    act(() => window.dispatchEvent(new Event('pagehide')))
+
+    const after = await relaunch()
+    renderComposer(after, 'pane:tab-1:leaf', null, 'pane:tab-1:leaf')
+
+    expect(after.cache.readNativeChatDraftCache('pane:tab-1:leaf')).toBe(`${seeded} edited`)
+    expect(mocks.seedNativeChatLaunchDraft).toHaveBeenCalledWith({
+      tabId: 'tab-1',
+      agent: 'claude',
+      text: seeded,
+      createdAt: SEEDED_AT,
+      adopted: true
+    })
+    const { resolveNativeChatLaunchDraftSend } = await import('./native-chat-launch-draft-send')
+    const { plan } = resolveNativeChatLaunchDraftSend({
+      launchDraft: mocks.seedNativeChatLaunchDraft.mock.calls[0]?.[0],
+      launchDraftResolved: false,
+      agent: 'claude',
+      readScreen: () => null
+    })
+    expect(plan).toMatchObject({ kind: 'replace-draft', seededText: seeded })
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-launch-draft-adoption.ts b/src/renderer/src/components/native-chat/use-native-chat-launch-draft-adoption.ts
index 2b2e176a30b..5a7ab77739c 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-launch-draft-adoption.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-launch-draft-adoption.ts
@@ -2,6 +2,11 @@ import { useEffect, useMemo, useState } from 'react'
 import { useAppStore } from '../../store'
 import type { NativeChatLaunchDraft } from '@/lib/native-chat-launch-prompt'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
+import type { NativeChatLaunchSeed } from './native-chat-composer-types'
+import {
+  readNativeChatDraftTuiInputSeed,
+  writeNativeChatDraftTuiInputSeed
+} from './native-chat-draft-cache'
 import {
   launchDraftResolvedByTranscript,
   nativeChatLaunchDraftTurnBaseline,
@@ -74,31 +79,37 @@ export function useNativeChatLaunchDraftSignal(args: {
  * - unadopted + composer in use     → mark adopted without copying (never stomp)
  * - resolved by transcript          → clear the composer copy while it is still
  *                                     the untouched seed text, and drop the seed
+ *
+ * A chat over a terminal agent saves the seed with its draft when adopting it, because the
+ * agent's input line still holds it after a relaunch while the seed record does not survive;
+ * the record is re-seeded from there so a send still replaces the line.
  */
 export function useNativeChatLaunchDraftAdoption(args: {
   terminalTabId: string
   agent: string
-  launchDraft: NativeChatLaunchDraft | null | undefined
-  launchDraftResolved: boolean
+  launchSeed: NativeChatLaunchSeed | undefined
+  /** The chat's draft when its agent has a terminal input line; a structured chat has none. */
+  tuiDraftKey: string | undefined
   draft: string
   setDraft: (next: string) => void
   setCaret: (next: number) => void
-  /** This pane is the tab-wide evidence's owner (`nativeChatLeafOwnsTabWideEvidence`).
-   *  Splitting drops it for every pane, so it gates pickup, never cleanup. */
-  ownsTabWideLaunchDraft: boolean
 }): void {
-  const {
-    terminalTabId,
-    agent,
-    launchDraft,
-    launchDraftResolved,
-    draft,
-    setDraft,
-    setCaret,
-    ownsTabWideLaunchDraft
-  } = args
+  const { terminalTabId, agent, launchSeed, tuiDraftKey, draft, setDraft, setCaret } = args
+  const launchDraft = launchSeed?.launchDraft
+  const launchDraftResolved = launchSeed?.launchDraftResolved === true
+  // Splitting drops tab-wide ownership for every pane, so it gates pickup, never cleanup.
+  const ownsTabWideLaunchDraft = launchSeed?.ownsTabWideLaunchDraft === true
   useEffect(() => {
-    if (!launchDraft || launchDraft.agent !== agent) {
+    if (!launchDraft) {
+      const seed = tuiDraftKey ? readNativeChatDraftTuiInputSeed(tuiDraftKey) : undefined
+      if (seed?.agent === agent) {
+        useAppStore
+          .getState()
+          .seedNativeChatLaunchDraft({ tabId: terminalTabId, ...seed, adopted: true })
+      }
+      return
+    }
+    if (launchDraft.agent !== agent) {
       return
     }
     if (launchDraftResolved) {
@@ -127,6 +138,10 @@ export function useNativeChatLaunchDraftAdoption(args: {
     // Mark adopted before copying so a composer that already holds user text
     // declines the seed permanently instead of resurrecting it on a later clear.
     useAppStore.getState().markNativeChatLaunchDraftAdopted(terminalTabId)
+    if (tuiDraftKey) {
+      const { agent: seedAgent, text, createdAt } = launchDraft
+      writeNativeChatDraftTuiInputSeed(tuiDraftKey, { agent: seedAgent, text, createdAt })
+    }
     if (draft === '') {
       setDraft(launchDraft.text)
       setCaret(launchDraft.text.length)
@@ -139,6 +154,7 @@ export function useNativeChatLaunchDraftAdoption(args: {
     ownsTabWideLaunchDraft,
     setCaret,
     setDraft,
-    terminalTabId
+    terminalTabId,
+    tuiDraftKey
   ])
 }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.test.tsx
index 7584dcc15a4..70140a626b2 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.test.tsx
@@ -1,8 +1,13 @@
 // @vitest-environment happy-dom
 
 import { act, renderHook } from '@testing-library/react'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { EMPTY_HISTORY } from './native-chat-composer-state'
+import {
+  clearNativeChatDraftCacheForTests,
+  writeNativeChatDraftCache
+} from './native-chat-draft-cache'
+import { installNativeChatDrafts } from './native-chat-draft-store.test-support'
 
 const sendNativeChatMessage = vi.fn()
 const sendNativeChatTypedCommand = vi.fn()
@@ -28,17 +33,21 @@ const COMMAND = {
   skillCollision: false
 }
 
+const DRAFT_KEY = 'pane:tab-1:leaf-1'
+
 function renderDispatch(agent: 'codex' | 'claude' | 'openclaude') {
   return renderHook(() =>
     useNativeChatPickerCommandDispatch({
       agent,
+      draftKey: DRAFT_KEY,
       disabled: false,
       isDispatchingSessionOption: false,
       resolveTarget: () => ({ settings: {}, ptyId: 'pty-1' }),
       sessionOptionsSurface: null,
       trackPendingSend: vi.fn(),
       setHistory: vi.fn((update) => update(EMPTY_HISTORY)),
-      setDraft: vi.fn(),
+      // As the composer's draft hook does: a clear is saved at once.
+      setDraft: (value: string) => writeNativeChatDraftCache(DRAFT_KEY, value, 'now'),
       setCaret: vi.fn(),
       setActiveSuggestion: vi.fn(),
       clearSkillOrigin: vi.fn(),
@@ -56,6 +65,12 @@ describe('useNativeChatPickerCommandDispatch', () => {
     sendNativeChatTypedCommand.mockReturnValue(handle)
   })
 
+  afterEach(async () => {
+    // Lets each send's draft save land in its own test.
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    clearNativeChatDraftCacheForTests()
+  })
+
   it('types Codex autocomplete commands', () => {
     const hook = renderDispatch('codex')
     act(() => hook.result.current(COMMAND))
@@ -72,3 +87,43 @@ describe('useNativeChatPickerCommandDispatch', () => {
     expect(sendNativeChatTypedCommand).not.toHaveBeenCalled()
   })
 })
+
+// A command picked from the menu goes out like a typed one: its clear is saved once the
+// terminal write ran, so a crash before then restores it unsent.
+describe('a command picked from the menu', () => {
+  afterEach(async () => {
+    // Lets each send's draft save land in its own test.
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    clearNativeChatDraftCacheForTests()
+  })
+
+  it('keeps its text saved until the terminal write ran', async () => {
+    const saved: unknown[] = []
+    installNativeChatDrafts({
+      load: async () => [],
+      loadSync: () => [],
+      write: async (_scopeKey, draft) => {
+        saved.push(draft?.text ?? null)
+        return 'persisted'
+      }
+    })
+    let finish = () => {}
+    sendNativeChatTypedCommand.mockReturnValue({
+      cancel: vi.fn(),
+      settleAfterMs: 0,
+      settled: new Promise<void>((resolve) => {
+        finish = resolve
+      })
+    })
+    writeNativeChatDraftCache(DRAFT_KEY, '/sta', 'now')
+    const hook = renderDispatch('codex')
+
+    act(() => hook.result.current(COMMAND))
+    await Promise.resolve()
+    expect(sendNativeChatTypedCommand).toHaveBeenCalledWith({}, 'pty-1', '/status')
+    expect(saved).toEqual(['/sta'])
+
+    finish()
+    await vi.waitFor(() => expect(saved).toEqual(['/sta', null]))
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.ts b/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.ts
index 0022514fd97..2fe1d9799e2 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-picker-command-dispatch.ts
@@ -17,9 +17,13 @@ import {
 } from './native-chat-composer-state'
 import type { NativeChatSendLifecycle } from './use-native-chat-send-lifecycle'
 import type { NativeChatPtySessionOptionsSurface } from './native-chat-pty-session-options'
+import { clearNativeChatDraftForSend } from './native-chat-draft-cache'
+import { saveNativeChatDraftAfterPtyWrite } from './native-chat-draft-save-after-send'
 
 export function useNativeChatPickerCommandDispatch(args: {
   agent: AgentType
+  /** The chat's draft (`nativeChatDraftKey`); its clear is saved once the terminal has the command. */
+  draftKey: string
   disabled: boolean
   isDispatchingSessionOption: boolean
   resolveTarget: () => NativeChatResolvedTarget | null
@@ -36,6 +40,7 @@ export function useNativeChatPickerCommandDispatch(args: {
 }): (command: Extract<NativeChatPickerItem, { kind: 'command' }>) => void {
   const {
     agent,
+    draftKey,
     disabled,
     isDispatchingSessionOption,
     resolveTarget,
@@ -57,11 +62,11 @@ export function useNativeChatPickerCommandDispatch(args: {
       if (!target || disabled || isDispatchingSessionOption) {
         return
       }
-      trackPendingSend(
+      const handle =
         agent === 'codex'
           ? sendNativeChatTypedCommand(target.settings, target.ptyId, text)
           : sendNativeChatMessage(target.settings, target.ptyId, text)
-      )
+      trackPendingSend(handle)
       emitNativeChatPickerItemAccepted({ agent, itemKind: 'command' })
       // Why: picker dispatch is a catalog-verified command send; it must leave
       // the same telemetry and composer state as the typed path — including
@@ -74,18 +79,22 @@ export function useNativeChatPickerCommandDispatch(args: {
         runtime: nativeChatComposerTargetIsRemote(target.ptyId) ? 'remote' : 'local'
       })
       setHistory((previous) => pushHistory(previous, text))
-      setDraft('')
-      setCaret(0)
-      setActiveSuggestion(0)
-      clearSkillOrigin()
-      clearImageAttachments()
-      setNotice(null)
+      const saveDraft = clearNativeChatDraftForSend(draftKey, () => {
+        setDraft('')
+        setCaret(0)
+        setActiveSuggestion(0)
+        clearSkillOrigin()
+        clearImageAttachments()
+        setNotice(null)
+      })
+      saveNativeChatDraftAfterPtyWrite(handle, saveDraft)
     },
     [
       agent,
       clearImageAttachments,
       clearSkillOrigin,
       disabled,
+      draftKey,
       isDispatchingSessionOption,
       onSlashCommand,
       resolveTarget,
diff --git a/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.test.tsx
index b480c065e91..84d417dca86 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.test.tsx
@@ -1,13 +1,28 @@
 // @vitest-environment happy-dom
 import { renderHook } from '@testing-library/react'
-import { beforeEach, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { AgentType } from '../../../../shared/agent-status-types'
 import type { NativeChatSendClassification } from '../../../../shared/native-chat-slash-commands'
 import { useNativeChatPtyComposerSend } from './use-native-chat-pty-composer-send'
 import { sendNativeChatMessage } from './native-chat-runtime-send'
 import { sendNativeChatMessageWithImageAttachments } from './native-chat-runtime-image-send'
+import {
+  addNativeChatDraftAttachments,
+  clearNativeChatDraftAttachments,
+  clearNativeChatDraftCacheForTests,
+  forgetNativeChatTuiInputSeeds,
+  writeNativeChatDraftCache,
+  writeNativeChatDraftTuiInputSeed
+} from './native-chat-draft-cache'
+import { installNativeChatDrafts } from './native-chat-draft-store.test-support'
 
-const handle = vi.hoisted(() => ({ cancel: () => {}, settleAfterMs: 0 }))
+const handle = vi.hoisted(() => {
+  const sendHandle: { cancel: () => void; settleAfterMs: number; settled?: Promise<void> } = {
+    cancel: () => {},
+    settleAfterMs: 0
+  }
+  return sendHandle
+})
 vi.mock('./native-chat-runtime-send', () => ({
   sendNativeChatMessage: vi.fn(() => handle),
   sendNativeChatTypedCommand: vi.fn(() => handle),
@@ -17,20 +32,25 @@ vi.mock('./native-chat-runtime-image-send', () => ({
   sendNativeChatMessageWithImageAttachments: vi.fn(() => handle)
 }))
 vi.mock('../../store', () => ({
-  useAppStore: { getState: () => ({ clearNativeChatLaunchDraft: vi.fn() }) }
+  // As the store does: dropping the launch draft forgets its input-line seeds.
+  useAppStore: { getState: () => ({ clearNativeChatLaunchDraft: forgetNativeChatTuiInputSeeds }) }
 }))
 vi.mock('@/lib/native-chat-telemetry', () => ({ emitNativeChatMessageSent: vi.fn() }))
 
+const DRAFT_KEY = 'pane:tab:leaf'
+
 function send(
   agent: AgentType,
   classification: NativeChatSendClassification,
   draft: string,
-  imagePaths: string[] = []
+  imagePaths: string[] = [],
+  clearImageAttachments: () => void = vi.fn()
 ) {
   const callbacks = { rejected: vi.fn(), unconfirmed: vi.fn() }
   const { result } = renderHook(() =>
     useNativeChatPtyComposerSend({
       agent,
+      draftKey: DRAFT_KEY,
       draft,
       imageAttachments: imagePaths.map((path) => ({ path })),
       disabled: false,
@@ -44,10 +64,11 @@ function send(
       terminalTabId: 'tab',
       trackPendingSend: vi.fn(),
       setHistory: vi.fn(),
-      setDraft: vi.fn(),
+      // As the composer's draft hook does: a clear is saved at once.
+      setDraft: (value: string) => writeNativeChatDraftCache(DRAFT_KEY, value, 'now'),
       setCaret: vi.fn(),
       clearSkillOrigin: vi.fn(),
-      clearImageAttachments: vi.fn(),
+      clearImageAttachments,
       setNotice: vi.fn()
     })
   )
@@ -55,9 +76,27 @@ function send(
   return callbacks
 }
 
+let saved: unknown[] = []
+
 beforeEach(() => {
   vi.mocked(sendNativeChatMessage).mockClear()
   vi.mocked(sendNativeChatMessageWithImageAttachments).mockClear()
+  saved = []
+  installNativeChatDrafts({
+    load: async () => [],
+    loadSync: () => [],
+    write: async (_scopeKey, draft) => {
+      saved.push(draft?.text ?? null)
+      return 'persisted'
+    }
+  })
+})
+
+afterEach(async () => {
+  handle.settled = undefined
+  // Lets each send's draft save land in its own test.
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  clearNativeChatDraftCacheForTests()
 })
 
 it('routes a Claude chat send outcome to its own pending echo', () => {
@@ -82,3 +121,114 @@ it.each([
   send(agent, classification, draft)
   expect(vi.mocked(sendNativeChatMessage).mock.calls[0]?.[3]?.onWriteRejected).toBeUndefined()
 })
+
+// A crash before the agent has the message must restore it unsent, and one after must not bring
+// it back, so the box's clear is saved only once the terminal write ran.
+describe('the saved draft at send', () => {
+  function writeRuns(): () => void {
+    let finish = () => {}
+    handle.settled = new Promise<void>((resolve) => {
+      finish = resolve
+    })
+    return finish
+  }
+
+  it('keeps the message saved until the terminal write ran, then saves the empty box', async () => {
+    writeNativeChatDraftCache(DRAFT_KEY, 'hello', 'now')
+    const finish = writeRuns()
+
+    send('codex', 'chat', 'hello')
+    await Promise.resolve()
+
+    expect(sendNativeChatMessage).toHaveBeenCalledOnce()
+    expect(saved).toEqual(['hello'])
+    finish()
+    await vi.waitFor(() => expect(saved).toEqual(['hello', null]))
+  })
+
+  it('keeps what was typed after Enter when it saves', async () => {
+    writeNativeChatDraftCache(DRAFT_KEY, 'hello', 'now')
+    const finish = writeRuns()
+    send('codex', 'chat', 'hello')
+
+    writeNativeChatDraftCache(DRAFT_KEY, 'next thought', 'after-pause')
+    finish()
+
+    await vi.waitFor(() => expect(saved.at(-1)).toBe('next thought'))
+    expect(saved).not.toContain(null)
+  })
+
+  it('saves the message typed just before Enter that was still waiting for its pause', async () => {
+    writeNativeChatDraftCache(DRAFT_KEY, 'hello', 'after-pause')
+    const finish = writeRuns()
+
+    send('codex', 'chat', 'hello')
+
+    expect(saved).toEqual(['hello'])
+    finish()
+    await vi.waitFor(() => expect(saved).toEqual(['hello', null]))
+  })
+
+  it('saves only once the last of several sends in flight has reached the terminal', async () => {
+    writeNativeChatDraftCache(DRAFT_KEY, 'first', 'now')
+    const finishFirst = writeRuns()
+    send('codex', 'chat', 'first')
+    writeNativeChatDraftCache(DRAFT_KEY, 'second', 'now')
+    const finishSecond = writeRuns()
+    send('codex', 'chat', 'second')
+
+    finishFirst()
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(saved).not.toContain(null)
+
+    finishSecond()
+    await vi.waitFor(() => expect(saved.at(-1)).toBeNull())
+  })
+
+  // A rejected write delivered nothing, so the message must still be there after a relaunch.
+  it('keeps the message saved when the terminal rejected the write', async () => {
+    writeNativeChatDraftCache(DRAFT_KEY, 'hello', 'now')
+    const finish = writeRuns()
+    send('claude', 'chat', 'hello')
+
+    vi.mocked(sendNativeChatMessage).mock.calls[0]?.[3]?.onWriteRejected?.()
+    finish()
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(saved).toEqual(['hello'])
+  })
+
+  // The whole clear a real send does: text, image chips, editor and the launch seed.
+  it('writes nothing without the message until the terminal write ran, with images and a seed', async () => {
+    const writes: { text: string; chips: number; seed: boolean }[] = []
+    installNativeChatDrafts({
+      load: async () => [],
+      loadSync: () => [],
+      write: async (_scopeKey, draft) => {
+        writes.push({
+          text: draft?.text ?? '',
+          chips: draft?.attachments.length ?? 0,
+          seed: draft?.tuiInputSeed !== undefined
+        })
+        return 'persisted'
+      }
+    })
+    writeNativeChatDraftTuiInputSeed(DRAFT_KEY, { agent: 'claude', text: 'Fix #12', createdAt: 1 })
+    addNativeChatDraftAttachments(DRAFT_KEY, [
+      { id: 'shot', path: '/tmp/shot.png', location: 'local' }
+    ])
+    writeNativeChatDraftCache(DRAFT_KEY, 'look', 'now')
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    writes.length = 0
+    const finish = writeRuns()
+
+    send('claude', 'chat', 'look', ['/tmp/shot.png'], () =>
+      clearNativeChatDraftAttachments(DRAFT_KEY)
+    )
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(writes).toEqual([])
+    finish()
+    await vi.waitFor(() => expect(writes.at(-1)).toEqual({ text: '', chips: 0, seed: false }))
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts
index 385396190e4..cadf6e9b089 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-pty-composer-send.ts
@@ -19,9 +19,13 @@ import type { NativeChatPickerState } from './use-native-chat-picker-state'
 import type { NativeChatSendLifecycle } from './use-native-chat-send-lifecycle'
 import type { NativeChatPtySessionOptionsSurface } from './native-chat-pty-session-options'
 import type { NativeChatOptimisticSendOutcome } from './native-chat-composer-types'
+import { clearNativeChatDraftForSend } from './native-chat-draft-cache'
+import { saveNativeChatDraftAfterPtyWrite } from './native-chat-draft-save-after-send'
 
 export function useNativeChatPtyComposerSend(args: {
   agent: AgentType
+  /** The chat's draft (`nativeChatDraftKey`); its clear is saved once the terminal has the message. */
+  draftKey: string
   draft: string
   imageAttachments: readonly { path: string }[]
   disabled: boolean
@@ -66,11 +70,13 @@ export function useNativeChatPtyComposerSend(args: {
       readScreen: () => args.readTerminalScreen?.()
     })
     let pendingId: string | undefined
+    let writeRejected = false
     const sendOptions =
       args.agent === 'claude' && classification === 'chat'
         ? {
             ...launchSendOptions,
             onWriteRejected: () => {
+              writeRejected = true
               if (pendingId) {
                 args.optimisticSendOutcome?.reject(pendingId)
               }
@@ -122,11 +128,20 @@ export function useNativeChatPtyComposerSend(args: {
       runtime: nativeChatComposerTargetIsRemote(target.ptyId) ? 'remote' : 'local'
     })
     args.setHistory((previous) => pushHistory(previous, text))
-    args.setDraft('')
-    args.setCaret(0)
-    args.clearSkillOrigin()
-    args.clearImageAttachments()
-    args.setNotice(null)
-    useAppStore.getState().clearNativeChatLaunchDraft(args.terminalTabId)
+    // The box empties now; its saved draft keeps the message until the terminal has it.
+    const saveDraft = clearNativeChatDraftForSend(args.draftKey, () => {
+      args.setDraft('')
+      args.setCaret(0)
+      args.clearSkillOrigin()
+      args.clearImageAttachments()
+      args.setNotice(null)
+      useAppStore.getState().clearNativeChatLaunchDraft(args.terminalTabId)
+    })
+    // A rejected write delivered nothing: the saved draft keeps the message.
+    saveNativeChatDraftAfterPtyWrite(pendingHandle, () => {
+      if (!writeRejected) {
+        saveDraft()
+      }
+    })
   }, [args])
 }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-resolved-path-attachments.ts b/src/renderer/src/components/native-chat/use-native-chat-resolved-path-attachments.ts
index 7bc6a042abc..555c5b85bf3 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-resolved-path-attachments.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-resolved-path-attachments.ts
@@ -13,10 +13,13 @@ type ResolvedAttachmentPath = {
   path: string
   connectionId?: string | null
   targetOwnerIsCurrent?: () => boolean
+  onRuntimeHost?: boolean
 }
 
 type Args = {
-  appendImageAttachments: (paths: { path: string; connectionId?: string | null }[]) => void
+  appendImageAttachments: (
+    paths: { path: string; connectionId?: string | null; onRuntimeHost?: boolean }[]
+  ) => void
   attachmentTargetBlocked: (targetOwned?: boolean) => boolean
   caret: number
   disabled: boolean
@@ -112,7 +115,13 @@ export function useNativeChatResolvedPathAttachments({
         .filter(({ path }) => !isNativeChatImageAttachmentPath(path))
         .map(({ path }) => path)
       // Images ride along on submit so chips and the TUI input cannot diverge.
-      appendImageAttachments(imagePaths.map(({ path, connectionId }) => ({ path, connectionId })))
+      appendImageAttachments(
+        imagePaths.map(({ path, connectionId, onRuntimeHost }) => ({
+          path,
+          connectionId,
+          onRuntimeHost
+        }))
+      )
       insertFileReferences(filePaths)
       if (ownedBlocked || clientLocalBlocked) {
         noteAttachmentTargetBlocked()
@@ -167,7 +176,8 @@ export function useNativeChatResolvedPathAttachments({
           ...paths.map((path) => ({
             path,
             connectionId,
-            targetOwnerIsCurrent: options.targetOwnerIsCurrent
+            targetOwnerIsCurrent: options.targetOwnerIsCurrent,
+            onRuntimeHost: options.onRuntimeHost
           }))
         )
         return
@@ -176,7 +186,8 @@ export function useNativeChatResolvedPathAttachments({
         paths.map((path) => ({
           path,
           connectionId,
-          targetOwnerIsCurrent: options.targetOwnerIsCurrent
+          targetOwnerIsCurrent: options.targetOwnerIsCurrent,
+          onRuntimeHost: options.onRuntimeHost
         })),
         true
       )
diff --git a/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.test.tsx b/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.test.tsx
index 39892a49219..a72bc60ee24 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.test.tsx
+++ b/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.test.tsx
@@ -40,6 +40,7 @@ function harness(
   }
   const { result } = renderHook(() =>
     useNativeChatStructuredComposerSend({
+      draftKey: 'session:session-test',
       agent,
       draft: '',
       imageAttachments: [ATTACHMENT],
diff --git a/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.ts b/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.ts
index f208e6cb4a9..bd8e0b04acc 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-structured-composer-send.ts
@@ -10,9 +10,24 @@ import { dispatchNativeChatStructuredComposerText } from './native-chat-structur
 import { pushHistory, type HistoryState } from './native-chat-composer-state'
 import type { NativeChatStructuredComposerTransport } from './native-chat-composer-types'
 import type { NativeChatComposerImageAttachment } from './NativeChatComposerField'
+import {
+  clearNativeChatDraftForHeldSend,
+  restoreNativeChatDraftIfEmpty,
+  saveNativeChatDraftNow
+} from './native-chat-draft-cache'
+import {
+  holdNativeChatDraftSend,
+  releaseNativeChatHeldSend,
+  renameNativeChatHeldSend
+} from './native-chat-held-sends'
+import { nativeChatDraftAttachmentsOf } from './native-chat-draft-save-after-send'
+import { getStructuredAgentSessionOutbox } from './structured-agent-session-outbox-storage'
+import { whenStructuredAgentSessionHostHasMessages } from './structured-agent-session-message-delivery'
 
 export type UseNativeChatStructuredComposerSendArgs = {
   agent: AgentType
+  /** The chat's draft (`nativeChatDraftKey`), where a refused message is put back. */
+  draftKey: string
   draft?: string
   imageAttachments: readonly NativeChatComposerImageAttachment[]
   structuredTransport?: NativeChatStructuredComposerTransport
@@ -23,10 +38,12 @@ export type UseNativeChatStructuredComposerSendArgs = {
   setCaret: (caret: number) => void
 }
 
-/** Send through the structured journal transport, clearing the composer only
- *  once the transport accepts (the PTY path has its own sibling hook). */
+/** Send through the structured journal transport (the PTY path has its own sibling hook). A
+ *  message clears the composer before the transport takes it and is put back if refused; a host
+ *  command clears it only once accepted. */
 export function useNativeChatStructuredComposerSend({
   agent,
+  draftKey,
   draft,
   imageAttachments,
   structuredTransport,
@@ -56,33 +73,86 @@ export function useNativeChatStructuredComposerSend({
         return
       }
       const submitted = composition.current
-      void dispatchNativeChatStructuredComposerText(structuredTransport, text, attachments)
-        .then(({ accepted, error }) => {
-          structuredTransport.onError(error)
-          if (!accepted) {
-            return
-          }
-          emitNativeChatMessageSent({ agent, runtime: structuredTransport.runtime })
-          // A real user send is a takeover, exactly as typing into a worker's pane is. Only past
-          // `accepted`, and only from this hook: the outbox dispatcher retries and would re-fire,
-          // and orchestration's own pointer nudges never reach the composer at all.
-          reportStructuredSessionUserInput(
-            structuredTransport.sessionId,
-            structuredTransport.runtimeEnvironmentId
+      const clearComposer = (): void => {
+        setDraft('')
+        setCaret(0)
+        clearSkillOrigin()
+        clearImageAttachments()
+      }
+      let cleared = false
+      let outboxBefore: ReadonlySet<string> = new Set()
+      const sent = { text, attachments: nativeChatDraftAttachmentsOf(attachments) }
+      // A refused message goes back, unless something was typed since. The clear was never saved,
+      // so saving the draft afterwards keeps what the box shows.
+      const putBack = (): void => {
+        if (cleared) {
+          void restoreNativeChatDraftIfEmpty(draftKey, sent)
+          void saveNativeChatDraftNow(draftKey)
+        }
+      }
+      void dispatchNativeChatStructuredComposerText(structuredTransport, text, attachments, () => {
+        // The box empties now, and is saved once the send has its id, together with the message as
+        // a held send kept until the host has it: a crash before then restores it unsent, and a
+        // crash after cannot bring it back.
+        cleared = true
+        outboxBefore = new Set(
+          getStructuredAgentSessionOutbox(structuredTransport.sessionId).map(
+            (entry) => entry.clientMessageId
           )
-          setHistory((previous) => pushHistory(previous, text))
-          if (
-            hostCommand &&
-            (composition.current.draft !== submitted.draft ||
-              composition.current.imageAttachments !== submitted.imageAttachments)
-          ) {
-            return
+        )
+        clearNativeChatDraftForHeldSend(draftKey, clearComposer)
+      })
+        .then(
+          ({ accepted, error }) => {
+            structuredTransport.onError(error)
+            if (!accepted) {
+              putBack()
+              return
+            }
+            // The held send goes once the host holds the message for good (the agent accepted it,
+            // or a card), or it is withdrawn back into the box or dropped; a refusal's new id
+            // renames it.
+            if (cleared) {
+              const entry = getStructuredAgentSessionOutbox(structuredTransport.sessionId).find(
+                (candidate) => !outboxBefore.has(candidate.clientMessageId)
+              )
+              holdNativeChatDraftSend(draftKey, sent, entry?.clientMessageId)
+              if (entry) {
+                let heldAs = entry.clientMessageId
+                void whenStructuredAgentSessionHostHasMessages(
+                  structuredTransport.sessionId,
+                  [entry],
+                  (from, to) => {
+                    renameNativeChatHeldSend(draftKey, from, to)
+                    heldAs = to
+                  }
+                ).then(() => releaseNativeChatHeldSend(draftKey, heldAs))
+              }
+            }
+            emitNativeChatMessageSent({ agent, runtime: structuredTransport.runtime })
+            // A real user send is a takeover, exactly as typing into a worker's pane is. Only past
+            // `accepted`, and only from this hook: the outbox dispatcher retries and would re-fire,
+            // and orchestration's own pointer nudges never reach the composer at all.
+            reportStructuredSessionUserInput(
+              structuredTransport.sessionId,
+              structuredTransport.runtimeEnvironmentId
+            )
+            setHistory((previous) => pushHistory(previous, text))
+            if (
+              cleared ||
+              (hostCommand &&
+                (composition.current.draft !== submitted.draft ||
+                  composition.current.imageAttachments !== submitted.imageAttachments))
+            ) {
+              return
+            }
+            clearComposer()
+          },
+          (error: unknown) => {
+            putBack()
+            throw error
           }
-          setDraft('')
-          setCaret(0)
-          clearSkillOrigin()
-          clearImageAttachments()
-        })
+        )
         .catch((error) =>
           structuredTransport.onError(error instanceof Error ? error.message : String(error))
         )
@@ -91,6 +161,7 @@ export function useNativeChatStructuredComposerSend({
       agent,
       clearImageAttachments,
       clearSkillOrigin,
+      draftKey,
       imageAttachments,
       setCaret,
       setDraft,
diff --git a/src/renderer/src/components/native-chat/use-native-chat-workspace-file-drop.ts b/src/renderer/src/components/native-chat/use-native-chat-workspace-file-drop.ts
index cc37d7783a2..433398d0a0a 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-workspace-file-drop.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-workspace-file-drop.ts
@@ -162,7 +162,8 @@ export function useNativeChatWorkspaceFileDrop({
       }
 
       attachResolvedPaths(dragPaths.paths, owner.kind === 'ssh' ? owner.connectionId : undefined, {
-        targetOwnerIsCurrent
+        targetOwnerIsCurrent,
+        onRuntimeHost: owner.kind === 'runtime'
       })
     },
     [attachResolvedPaths, disabled, setNotice, structuredWorktreeId, terminalTabId]
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.host-has-message.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.host-has-message.test.tsx
new file mode 100644
index 00000000000..81755e69352
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.host-has-message.test.tsx
@@ -0,0 +1,120 @@
+// @vitest-environment happy-dom
+
+// A watched send settles once the journal's answer takes its entry out of the outbox: accepted by
+// the agent. One the host accepted but has not handed over, or handed over but the agent has not
+// accepted, keeps its entry and stays watched.
+
+import { cleanup, renderHook, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import type { AgentJournalSubmission } from '../../../../shared/agent-session-journal-types'
+import { createStructuredAgentSessionOutboxEntry } from '../../../../shared/structured-agent-session-outbox'
+
+const mocks = vi.hoisted(() => ({ call: vi.fn() }))
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.call
+}))
+
+import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
+import { writeOutbox } from './structured-agent-session-outbox-storage'
+import { whenStructuredAgentSessionHostHasMessages } from './structured-agent-session-message-delivery'
+
+afterEach(cleanup)
+
+const ENTRY = {
+  ...createStructuredAgentSessionOutboxEntry({
+    clientMessageId: 'message-1',
+    sessionId: 'session-1',
+    text: 'mid-turn message',
+    attachments: [],
+    queuedAt: 1
+  }),
+  state: 'unconfirmed' as const,
+  lastAttemptAt: 5
+}
+
+function pending(
+  clientMessageId: string,
+  overrides: Partial<AgentJournalSubmission> = { handoverRecorded: true, handedOverAt: 12 }
+): AgentJournalSubmission {
+  return {
+    ...overrides,
+    clientMessageId,
+    fence: 1,
+    payloadFingerprint: 'fingerprint',
+    dispatchState: 'pending',
+    providerItemId: null,
+    reason: null,
+    submittedAt: 10,
+    resolvedAt: null
+  }
+}
+
+beforeEach(() => {
+  localStorage.clear()
+  mocks.call.mockReset()
+  mocks.call.mockImplementation(() => new Promise(() => {}))
+})
+
+it('releases the saved draft when the journal shows the agent accepted the message', async () => {
+  writeOutbox('session-1', [ENTRY])
+  let hostHasIt = false
+  void whenStructuredAgentSessionHostHasMessages('session-1', [ENTRY]).then(() => {
+    hostHasIt = true
+  })
+  type Props = { submissions: AgentJournalSubmission[] }
+  const noSubmissions: AgentJournalSubmission[] = []
+  const view = renderHook(
+    (props: Props) =>
+      useStructuredAgentSessionOutbox({
+        sessionId: 'session-1',
+        target: { kind: 'local' },
+        fence: 1,
+        submissions: props.submissions,
+        composerScopeKey: 'scope',
+        queueDelivery: { capability: 'supported', enabled: true }
+      }),
+    { initialProps: { submissions: noSubmissions } }
+  )
+  expect(hostHasIt).toBe(false)
+
+  view.rerender({ submissions: [{ ...pending('message-1'), dispatchState: 'accepted' }] })
+
+  await waitFor(() => expect(hostHasIt).toBe(true))
+  expect(view.result.current.outbox).toEqual([])
+})
+
+// A send mid-turn is handed over into the running turn at once; that is not the agent accepting it.
+it.each([
+  ['accepted by the host but not handed over', { handoverRecorded: true }],
+  ['handed over but not accepted by the agent', { handoverRecorded: true, handedOverAt: 12 }]
+] as const)(
+  'keeps the saved draft while the journal shows the message %s',
+  async (_label, overrides) => {
+    writeOutbox('session-1', [ENTRY])
+    let hostHasIt = false
+    void whenStructuredAgentSessionHostHasMessages('session-1', [ENTRY]).then(() => {
+      hostHasIt = true
+    })
+    type Props = { submissions: AgentJournalSubmission[] }
+    const noSubmissions: AgentJournalSubmission[] = []
+    const view = renderHook(
+      (props: Props) =>
+        useStructuredAgentSessionOutbox({
+          sessionId: 'session-1',
+          target: { kind: 'local' },
+          fence: 1,
+          submissions: props.submissions,
+          composerScopeKey: 'scope',
+          queueDelivery: { capability: 'supported', enabled: true }
+        }),
+      { initialProps: { submissions: noSubmissions } }
+    )
+
+    view.rerender({ submissions: [pending('message-1', overrides)] })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(hostHasIt).toBe(false)
+    expect(view.result.current.outbox.map((entry) => entry.clientMessageId)).toEqual(['message-1'])
+  }
+)
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts
index 51bfc048939..ffedcaf4b14 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.ts
@@ -63,6 +63,7 @@ export function useStructuredAgentSessionOutbox(args: {
   submissions: readonly AgentJournalSubmission[]
   /** The composer that gets back what a Stop withdrew from this client's outbox. */
   composerScopeKey?: string
+  composerWorktreeId?: string
   /** The host's queued-messages capability and the user's setting; a send stamped
    *  `delivery: 'queue-if-active'` is held as a draft only while the agent is working. */
   queueDelivery?: StructuredAgentSessionQueueDelivery
@@ -73,6 +74,7 @@ export function useStructuredAgentSessionOutbox(args: {
 }) {
   const {
     composerScopeKey,
+    composerWorktreeId,
     fence,
     queueDelivery = NO_QUEUE_DELIVERY,
     queuedMessageIds,
@@ -83,7 +85,11 @@ export function useStructuredAgentSessionOutbox(args: {
   const { capability: queueCapability, enabled: queueEnabled } = queueDelivery
   // What resends and drops a send in flight besides a Retry or a new send; see the hook.
   const owner = useStructuredAgentSessionOutboxOwnerChange(target, fence)
-  const restoreWithdrawn = useStructuredAgentSessionWithdrawnRestore(sessionId, composerScopeKey)
+  const restoreWithdrawn = useStructuredAgentSessionWithdrawnRestore(
+    sessionId,
+    composerScopeKey,
+    composerWorktreeId
+  )
   // The outbox lives in the session's store, shared with every other writer; this view holds it
   // open and drains it. Loading maps what a previous owner left mid-send.
   const load = useCallback(
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.test.tsx
index 5fdfc0a95c7..10ab3787f47 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.test.tsx
@@ -16,6 +16,10 @@ import {
   clearNativeChatDraftCacheForTests,
   readNativeChatDraftCache
 } from './native-chat-draft-cache'
+import {
+  installHeldNativeChatDrafts,
+  installNativeChatDrafts
+} from './native-chat-draft-store.test-support'
 import { useStructuredAgentSessionQueuedMessages } from './use-structured-agent-session-queued-messages'
 import type { StructuredAgentSessionMutate } from './use-structured-agent-session-mutate'
 
@@ -61,6 +65,11 @@ function createHarness(
 
 beforeEach(() => {
   clearNativeChatDraftCacheForTests()
+  installNativeChatDrafts({
+    load: async () => [],
+    loadSync: () => [],
+    write: async () => 'persisted'
+  })
 })
 
 afterEach(() => {
@@ -126,6 +135,44 @@ describe('queued message actions', () => {
     expect(readNativeChatDraftCache(SCOPE)).toBe('text of draft-1')
   })
 
+  // A crash between the host's delete and the copy reaching its file would lose the text.
+  it('Edit deletes the host copy only once the composer copy is written', async () => {
+    const writes = installHeldNativeChatDrafts()
+    const harness = createHarness()
+    let edited: Promise<void> = Promise.resolve()
+    act(() => {
+      edited = harness.result.current.edit('draft-1')
+    })
+    await waitFor(() => expect(writes).toHaveLength(1))
+    expect(harness.mutate).not.toHaveBeenCalled()
+
+    writes[0]?.settle('persisted')
+    await act(() => edited)
+    expect(harness.mutate).toHaveBeenCalledWith(
+      'agentSession.queuedMessageDelete',
+      'agentSession.queuedMessageDelete',
+      { messageId: 'draft-1' }
+    )
+  })
+
+  it('Edit still deletes the host copy when writing the composer copy fails or stalls', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const writes = installHeldNativeChatDrafts()
+    const failing = createHarness()
+    let edited: Promise<void> = Promise.resolve()
+    act(() => {
+      edited = failing.result.current.edit('draft-1')
+    })
+    await waitFor(() => expect(writes).toHaveLength(1))
+    writes[0]?.settle('failed')
+    await act(() => edited)
+    expect(failing.mutate).toHaveBeenCalledOnce()
+
+    const stalled = createHarness()
+    await act(() => stalled.result.current.edit('draft-2'))
+    expect(stalled.mutate).toHaveBeenCalledOnce()
+  })
+
   it('the text survives a failed Delete: the card stays and the composer keeps the copy', async () => {
     // mutate answers null for a refused or lost write; the card remains on the host's list.
     const harness = createHarness()
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.ts
index 4596fb67180..21da91225e1 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-queued-messages.ts
@@ -15,7 +15,7 @@ import type {
   AgentSessionQueuePause,
   AgentSessionSendResult
 } from '../../../../shared/agent-session-wire'
-import { appendNativeChatDraftCache } from './native-chat-draft-cache'
+import { appendNativeChatDraftNow, awaitNativeChatDraftWritten } from './native-chat-draft-cache'
 import {
   newestSteerableQueuedMessageCard,
   projectQueuedMessageCards,
@@ -121,13 +121,15 @@ export function useStructuredAgentSessionQueuedMessages(args: {
     (messageId: string): Promise<void> =>
       actOnce(messageId, async () => {
         // The text is copied FIRST, from the card this pane already shows — a local move,
-        // never a wire payload. Without a composer to hold it, deleting would destroy it,
-        // so the draft then stays a card.
+        // never a wire payload — and the copy is written (bounded wait) before the host's copy is
+        // deleted, so a crash between them leaves the text somewhere. Without a composer to hold
+        // it, deleting would destroy it, so the draft then stays a card.
         const card = cardsRef.current.find((entry) => entry.messageId === messageId)
         if (!card || !composerScopeKey) {
           return
         }
-        appendNativeChatDraftCache(composerScopeKey, card.text)
+        void appendNativeChatDraftNow(composerScopeKey, { text: card.text })
+        await awaitNativeChatDraftWritten(composerScopeKey)
         const result = await mutate<AgentSessionQueuedMessageDeleteResult>(
           'agentSession.queuedMessageDelete',
           'agentSession.queuedMessageDelete',
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session.ts b/src/renderer/src/components/native-chat/use-structured-agent-session.ts
index 96ad805560d..4d20aafa619 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session.ts
@@ -2,6 +2,7 @@ import { useMemo, useRef } from 'react'
 import * as structuredConversationCommands from './structured-conversation-command-send'
 import type { AgentSessionPromptResult } from '../../../../shared/agent-session-wire'
 import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
+import { useNativeChatHeldSends } from './use-native-chat-held-sends'
 import type {
   AgentSessionConversationCommand,
   AgentSessionConversationCommandResult
@@ -55,12 +56,15 @@ export function useStructuredAgentSession(args: {
   launch?: StructuredAgentSessionLaunchView
   /** The composer Edit copies a card's text into, and that gets back unsent outbox text. */
   composerScopeKey?: string
+  /** The composer's worktree, whose owner says where an image given back by a Stop lives. */
+  composerWorktreeId?: string
   /** The chat-wide "queue follow-ups" setting; off keeps mid-turn sends immediate. */
   queueFollowUps?: boolean
 }) {
   const {
     agent,
     composerScopeKey,
+    composerWorktreeId,
     isVisible,
     launch,
     providerStarting = false,
@@ -121,9 +125,15 @@ export function useStructuredAgentSession(args: {
     fence: transportState.fence,
     submissions: transportState.submissions,
     composerScopeKey,
+    composerWorktreeId,
     queueDelivery: { capability: queueCapability, enabled: queueFollowUps },
     queuedMessageIds
   })
+  useNativeChatHeldSends(composerScopeKey, {
+    status: transportEnabled ? state.status : 'idle',
+    submissions: transportState.submissions,
+    queuedMessages: transportState.queuedMessages
+  })
 
   const threadGoal = useStructuredAgentSessionThreadGoal({
     journalItems: transportState.journalItems,
diff --git a/src/renderer/src/components/terminal-pane/pending-split-close.test.ts b/src/renderer/src/components/terminal-pane/pending-split-close.test.ts
index 3ab94611f94..e488d56cf2a 100644
--- a/src/renderer/src/components/terminal-pane/pending-split-close.test.ts
+++ b/src/renderer/src/components/terminal-pane/pending-split-close.test.ts
@@ -206,3 +206,17 @@ it('commits the explicit split close in main by its leaf without waiting for its
   expect(p.state.terminalLayoutsByTabId[p.tabId].ptyIdsByLeafId?.[p.leafId]).toBeUndefined()
   expect(window.api.pty.kill).toHaveBeenCalledExactlyOnceWith('pty-restored')
 })
+
+it("explicit split close deletes the closed pane's chat draft and keeps its sibling's", async () => {
+  const p = await preparePendingSplitClose()
+  const drafts = await import('../native-chat/native-chat-draft-cache')
+  const closed = drafts.nativeChatDraftKey({ paneKey: `${p.tabId}:${p.leafId}` })
+  const sibling = drafts.nativeChatDraftKey({ paneKey: `${p.tabId}:${p.siblingLeafId}` })
+  drafts.appendNativeChatDraftNow(closed, { text: 'unsent' })
+  drafts.appendNativeChatDraftNow(sibling, { text: 'unsent' })
+
+  p.actions.executeClosePane(1)
+
+  expect(drafts.readNativeChatDraftCache(closed)).toBe('')
+  expect(drafts.readNativeChatDraftCache(sibling)).toBe('unsent')
+})
diff --git a/src/renderer/src/components/terminal-pane/terminal-pane-pane-closed.ts b/src/renderer/src/components/terminal-pane/terminal-pane-pane-closed.ts
index a70545c173c..285087590b6 100644
--- a/src/renderer/src/components/terminal-pane/terminal-pane-pane-closed.ts
+++ b/src/renderer/src/components/terminal-pane/terminal-pane-pane-closed.ts
@@ -15,6 +15,7 @@ import {
   discardDeferredSplitPaneHandoffForKey
 } from './deferred-split-pane-handoff'
 import type { PaneClosedHandlerContext } from './terminal-pane-mount-context'
+import { discardNativeChatDrafts } from '@/components/native-chat/native-chat-draft-cache'
 
 export function createTerminalPaneClosedHandler(
   context: Omit<PaneClosedHandlerContext, 'paneId' | 'closedPane'>
@@ -112,6 +113,8 @@ export function createTerminalPaneClosedHandler(
       })
     } else if (leafId && !isDetachedToTab) {
       useAppStore.getState().retireAgentPaneAuthority(makePaneKey(tabId, leafId))
+      // A closed leaf is never reused, so its chat draft is unreachable.
+      discardNativeChatDrafts({ paneKeys: [makePaneKey(tabId, leafId)] })
     }
     if (transport && !isRetiredSurface) {
       if (isDetachedToTab) {
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 2f29e560803..84ab7267d27 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -17712,6 +17712,7 @@
         "viewAttachment": "View image",
         "imagePreview": "Full-size image preview",
         "imagePreviewUnavailable": "Preview unavailable",
+        "imageMissing": "Image no longer available. Remove it to send.",
         "workspaceAttachmentMismatch": "Files can only be attached to their source workspace.",
         "attachmentOwnerChanged": "This workspace changed hosts while attaching — drop the files again.",
         "attachmentUnreadable": "Couldn't read the dropped files."
diff --git a/src/renderer/src/i18n/locales/es.json b/src/renderer/src/i18n/locales/es.json
index 45afe6f04a0..64814b43f75 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -15068,6 +15068,7 @@
         "removeAttachment": "Quitar archivo adjunto",
         "pastedImageLabel": "Imagen pegada",
         "imagePasteFailed": "Error al pegar imagen.",
+        "imageMissing": "La imagen ya no está disponible. Quítala para enviar.",
         "worktreeNotReady": "Worktree no está listo — intenta de nuevo en un momento.",
         "pasteUnavailable": "No se puede pegar — este chat no acepta entradas en este momento.",
         "uploadingAttachments": "Subiendo {{value0}} archivo(s) al remoto…",
diff --git a/src/renderer/src/i18n/locales/fr.json b/src/renderer/src/i18n/locales/fr.json
index 85a1b64c154..5e986faa539 100644
--- a/src/renderer/src/i18n/locales/fr.json
+++ b/src/renderer/src/i18n/locales/fr.json
@@ -17582,6 +17582,7 @@
         "viewAttachment": "Voir l'image",
         "imagePreview": "Aperçu de l'image en taille réelle",
         "imagePreviewUnavailable": "Aperçu indisponible",
+        "imageMissing": "L'image n'est plus disponible. Retirez-la pour envoyer.",
         "workspaceAttachmentMismatch": "Les fichiers ne peuvent être joints qu'à leur espace de travail source.",
         "attachmentOwnerChanged": "Cet espace de travail a changé d'hôte lors de la connexion : supprimez à nouveau les fichiers.",
         "attachmentUnreadable": "Impossible de lire les fichiers supprimés."
diff --git a/src/renderer/src/i18n/locales/ja.json b/src/renderer/src/i18n/locales/ja.json
index 0bed9bab422..d029a535bfc 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -17518,6 +17518,7 @@
         "viewAttachment": "画像を見る",
         "imagePreview": "フルサイズの画像プレビュー",
         "imagePreviewUnavailable": "プレビューは利用できません",
+        "imageMissing": "画像は利用できなくなりました。送信するには削除してください。",
         "workspaceAttachmentMismatch": "ファイルはソースワークスペースにのみ添付できます。",
         "attachmentOwnerChanged": "このワークスペースは接続中にホストを変更しました。ファイルを再度ドロップしてください。",
         "attachmentUnreadable": "ドロップされたファイルを読み取れませんでした。"
diff --git a/src/renderer/src/i18n/locales/ko.json b/src/renderer/src/i18n/locales/ko.json
index a503c3347d8..76d23656ffc 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -17518,6 +17518,7 @@
         "viewAttachment": "이미지 보기",
         "imagePreview": "전체 크기 이미지 미리보기",
         "imagePreviewUnavailable": "미리보기를 사용할 수 없습니다.",
+        "imageMissing": "이미지를 더 이상 사용할 수 없습니다. 보내려면 제거하세요.",
         "workspaceAttachmentMismatch": "파일은 소스 워크스페이스에만 첨부할 수 있습니다.",
         "attachmentOwnerChanged": "이 워크스페이스는 첨부하는 동안 호스트를 변경했습니다. 파일을 다시 삭제하세요.",
         "attachmentUnreadable": "삭제된 파일을 읽을 수 없습니다."
diff --git a/src/renderer/src/i18n/locales/zh.json b/src/renderer/src/i18n/locales/zh.json
index 63fc2b87de5..fd04a3d4552 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -17483,6 +17483,7 @@
         "viewAttachment": "查看图片",
         "imagePreview": "全尺寸图像预览",
         "imagePreviewUnavailable": "预览不可用",
+        "imageMissing": "图片已不可用。请移除后再发送。",
         "workspaceAttachmentMismatch": "文件只能附加到其源工作区。",
         "attachmentOwnerChanged": "此工作区在附加时更改了主机 - 再次删除文件。",
         "attachmentUnreadable": "无法读取删除的文件。"
diff --git a/src/renderer/src/runtime/structured-agent-session-tab-retirement.test.ts b/src/renderer/src/runtime/structured-agent-session-tab-retirement.test.ts
index 5c3017998c0..0e8bec97495 100644
--- a/src/renderer/src/runtime/structured-agent-session-tab-retirement.test.ts
+++ b/src/renderer/src/runtime/structured-agent-session-tab-retirement.test.ts
@@ -8,6 +8,7 @@ const mocks = vi.hoisted(() => ({
   callRuntime:
     vi.fn<(target: RuntimeClientTarget, method: string, params?: unknown) => Promise<unknown>>(),
   discardOutbox: vi.fn<(sessionId: string) => void>(),
+  discardDrafts: vi.fn<(ended: { sessionIds?: Iterable<string> }) => void>(),
   hasTombstone: vi.fn<(worktreeId: string, sessionId: string) => boolean>(),
   markCancelled: vi.fn<(worktreeId: string, sessionId: string) => boolean>()
 }))
@@ -19,6 +20,9 @@ vi.mock('@/lib/structured-agent-session-launch-registry', () => ({
 vi.mock('@/components/native-chat/structured-agent-session-outbox-storage', () => ({
   discardStructuredAgentSessionLaunchOutbox: mocks.discardOutbox
 }))
+vi.mock('@/components/native-chat/native-chat-draft-cache', () => ({
+  discardNativeChatDrafts: mocks.discardDrafts
+}))
 vi.mock('./structured-agent-session-close', () => ({
   closeStructuredAgentSession: mocks.closeSession
 }))
@@ -89,6 +93,7 @@ describe('structured agent session tab retirement', () => {
     })
     expect(mocks.markCancelled).toHaveBeenCalledWith('wt-1', 'session-1')
     expect(mocks.discardOutbox).toHaveBeenCalledWith('session-1')
+    expect(mocks.discardDrafts).toHaveBeenCalledWith({ sessionIds: ['session-1'] })
     await vi.waitFor(() => expect(mocks.callRuntime).toHaveBeenCalled())
     expect(mocks.closeSession).toHaveBeenCalledWith(target, 'session-1')
   })
diff --git a/src/renderer/src/runtime/structured-agent-session-tab-retirement.ts b/src/renderer/src/runtime/structured-agent-session-tab-retirement.ts
index 567e7459603..9e7fd7b7d0e 100644
--- a/src/renderer/src/runtime/structured-agent-session-tab-retirement.ts
+++ b/src/renderer/src/runtime/structured-agent-session-tab-retirement.ts
@@ -4,6 +4,7 @@ import {
   markStructuredAgentSessionLaunchCancelled
 } from '@/lib/structured-agent-session-launch-registry'
 import { discardStructuredAgentSessionLaunchOutbox } from '@/components/native-chat/structured-agent-session-outbox-storage'
+import { discardNativeChatDrafts } from '@/components/native-chat/native-chat-draft-cache'
 import { closeStructuredAgentSession } from './structured-agent-session-close'
 import { withLocalSessionTabCloseOwner } from './local-session-tab-close-owner'
 import { callRuntimeRpc, type RuntimeClientTarget } from './runtime-rpc-client'
@@ -67,6 +68,7 @@ export function beginStructuredAgentSessionTabClose(args: {
     markStructuredAgentSessionLaunchCancelled(args.worktreeId, args.sessionId)
   }
   discardStructuredAgentSessionLaunchOutbox(args.sessionId)
+  discardNativeChatDrafts({ sessionIds: [args.sessionId] })
   retireStructuredAgentSessionTab(args)
 }
 
diff --git a/src/renderer/src/startup/startup-runtime-session-hosts.ts b/src/renderer/src/startup/startup-runtime-session-hosts.ts
new file mode 100644
index 00000000000..dc071166e05
--- /dev/null
+++ b/src/renderer/src/startup/startup-runtime-session-hosts.ts
@@ -0,0 +1,12 @@
+import { toRuntimeExecutionHostId, type ExecutionHostId } from '../../../shared/execution-host'
+
+export async function listRuntimeSessionHostIdsForStartup(): Promise<ExecutionHostId[]> {
+  try {
+    return (await window.api.runtimeEnvironments.list()).map((environment) =>
+      toRuntimeExecutionHostId(environment.id)
+    )
+  } catch (err) {
+    console.warn('Failed to list runtime session hosts for startup:', err)
+    return []
+  }
+}
diff --git a/src/renderer/src/store/slices/bulk-worktree-purge-terminal-maps-leak.test.ts b/src/renderer/src/store/slices/bulk-worktree-purge-terminal-maps-leak.test.ts
index 0163aacc4c9..bc1ba2fc81c 100644
--- a/src/renderer/src/store/slices/bulk-worktree-purge-terminal-maps-leak.test.ts
+++ b/src/renderer/src/store/slices/bulk-worktree-purge-terminal-maps-leak.test.ts
@@ -47,7 +47,18 @@ const mockApi = {
 // @ts-expect-error -- minimal window.api stub for the store under test
 globalThis.window = { api: mockApi }
 
-import { createTestStore, seedStore, makeWorktree, makeTab } from './store-test-helpers'
+import {
+  createTestStore,
+  seedStore,
+  makeWorktree,
+  makeTab,
+  makeUnifiedTab
+} from './store-test-helpers'
+import {
+  appendNativeChatDraftNow,
+  nativeChatDraftKey,
+  readNativeChatDraftCache
+} from '@/components/native-chat/native-chat-draft-cache'
 import { parseRemoteRuntimePtyId } from '@/runtime/runtime-terminal-stream'
 import type { SshProviderEpoch } from '../../../../shared/ssh-types'
 import type { DirectSshPaneRetryAttemptId } from './direct-ssh-terminal-recovery'
@@ -216,6 +227,44 @@ describe('bulk worktree purge evicts the per-tab/per-pty terminal maps it previo
     expect(s.directSshPaneRetryHistoryByTabId[TAB2]).toBeDefined()
   })
 
+  it("drops the chat drafts of the removed worktree's panes and sessions, not the survivors'", () => {
+    const store = createTestStore()
+    seedMaps(store)
+    store.setState({
+      unifiedTabsByWorktree: {
+        [WT1]: [
+          makeUnifiedTab({
+            id: 'agent-session:s1',
+            entityId: 's1',
+            contentType: 'agent-session',
+            worktreeId: WT1,
+            groupId: 'g1'
+          })
+        ],
+        [WT2]: [
+          makeUnifiedTab({
+            id: 'agent-session:s2',
+            entityId: 's2',
+            contentType: 'agent-session',
+            worktreeId: WT2,
+            groupId: 'g2'
+          })
+        ]
+      }
+    })
+    const drafts = [
+      nativeChatDraftKey({ paneKey: `${TAB1}:leaf-1` }),
+      nativeChatDraftKey({ sessionId: 's1', paneKey: '' }),
+      nativeChatDraftKey({ paneKey: `${TAB2}:leaf-1` }),
+      nativeChatDraftKey({ sessionId: 's2', paneKey: '' })
+    ]
+    drafts.forEach((draftKey) => appendNativeChatDraftNow(draftKey, { text: 'unsent' }))
+
+    store.getState().purgeWorktreeTerminalState([WT1])
+
+    expect(drafts.map(readNativeChatDraftCache)).toEqual(['', '', 'unsent', 'unsent'])
+  })
+
   it('keeps environment-scoped remote guard identities independent', () => {
     const store = createTestStore()
     seedMaps(store)
diff --git a/src/renderer/src/store/slices/native-chat-launch-draft-teardown.test.ts b/src/renderer/src/store/slices/native-chat-launch-draft-teardown.test.ts
index d87c283ad23..19be795c730 100644
--- a/src/renderer/src/store/slices/native-chat-launch-draft-teardown.test.ts
+++ b/src/renderer/src/store/slices/native-chat-launch-draft-teardown.test.ts
@@ -39,6 +39,13 @@ const mockApi = {
 globalThis.window = { api: mockApi }
 
 import { createTestStore, seedStore, makeWorktree, makeTab } from './store-test-helpers'
+import {
+  appendNativeChatDraftNow,
+  nativeChatDraftKey,
+  readNativeChatDraftCache,
+  readNativeChatDraftTuiInputSeed,
+  writeNativeChatDraftTuiInputSeed
+} from '@/components/native-chat/native-chat-draft-cache'
 
 const WT1 = 'repo1::/path/wt1'
 const WT2 = 'repo1::/path/wt2'
@@ -108,6 +115,25 @@ describe('nativeChatLaunchDraftByTabId teardown', () => {
     expect(s.nativeChatLaunchDraftByTabId[TAB2]).toBeDefined()
   })
 
+  // Deleting a worktree drops its terminal tabs wholesale, never through closeTab.
+  it("single removeWorktree drops its terminal-agent chats' saved drafts and seeds only", async () => {
+    const store = createTestStore()
+    seedDrafts(store)
+    const removed = nativeChatDraftKey({ paneKey: `${TAB1}:leaf-1` })
+    const kept = nativeChatDraftKey({ paneKey: `${TAB2}:leaf-1` })
+    for (const key of [removed, kept]) {
+      appendNativeChatDraftNow(key, { text: 'unsent' })
+      writeNativeChatDraftTuiInputSeed(key, { agent: 'claude', text: 'issue', createdAt: 1 })
+    }
+
+    await store.getState().removeWorktree({ id: WT1, executionHostId: null })
+
+    expect(readNativeChatDraftCache(removed)).toBe('')
+    expect(readNativeChatDraftTuiInputSeed(removed)).toBeUndefined()
+    expect(readNativeChatDraftCache(kept)).toBe('unsent')
+    expect(readNativeChatDraftTuiInputSeed(kept)).toBeDefined()
+  })
+
   it('persists the adopted flag, idempotently, and clears the whole entry', () => {
     // Every consumer test injects these reducers as bare vi.fn()s. `adopted` is
     // what stops a manually cleared composer from resurrecting the prefill, so
diff --git a/src/renderer/src/store/slices/purge-stale-runtime-host-state.test.ts b/src/renderer/src/store/slices/purge-stale-runtime-host-state.test.ts
index 71cde0bac72..91474ac8e60 100644
--- a/src/renderer/src/store/slices/purge-stale-runtime-host-state.test.ts
+++ b/src/renderer/src/store/slices/purge-stale-runtime-host-state.test.ts
@@ -26,6 +26,11 @@ vi.mock('@/components/terminal-pane/pty-dispatcher', () => ({
 globalThis.window = { api: {} }
 
 import { createTestStore, seedStore, makeWorktree, makeTab, TEST_REPO } from './store-test-helpers'
+import {
+  appendNativeChatDraftNow,
+  nativeChatDraftKey,
+  readNativeChatDraftCache
+} from '@/components/native-chat/native-chat-draft-cache'
 
 const RUNTIME_A = toRuntimeExecutionHostId('env-a')
 const RUNTIME_NEVER_SAVED = toRuntimeExecutionHostId('env-serving-client')
@@ -115,6 +120,9 @@ describe('purgeStaleRuntimeHostState', () => {
       tabsByWorktree: { [WT_A]: [makeTab({ id: TAB_A, worktreeId: WT_A })] }
     })
     const epochBefore = store.getState().sortEpoch
+    // The host still has the chat; a re-pair or re-add publishes it again.
+    const paneDraft = nativeChatDraftKey({ paneKey: `${TAB_A}:leaf-1` })
+    appendNativeChatDraftNow(paneDraft, { text: 'unsent' })
 
     store.getState().purgeStaleRuntimeHostState(['env-a'])
 
@@ -130,6 +138,7 @@ describe('purgeStaleRuntimeHostState', () => {
     expect(s.worktreesByRepo.repoServing).toHaveLength(1)
     // sortEpoch bumped because rows changed.
     expect(s.sortEpoch).toBe(epochBefore + 1)
+    expect(readNativeChatDraftCache(paneDraft)).toBe('unsent')
   })
 
   it('keeps a still-saved sibling runtime env when another runtime env is removed', () => {
diff --git a/src/renderer/src/store/slices/worktrees/teardown/purge-stale-runtime-host-state.ts b/src/renderer/src/store/slices/worktrees/teardown/purge-stale-runtime-host-state.ts
index 8894499b714..69b5157296e 100644
--- a/src/renderer/src/store/slices/worktrees/teardown/purge-stale-runtime-host-state.ts
+++ b/src/renderer/src/store/slices/worktrees/teardown/purge-stale-runtime-host-state.ts
@@ -225,7 +225,12 @@ export function createPurgeStaleRuntimeHostState(
         const targets = removedWorktreeTargets.filter((target) => target.id === worktreeId)
         return targets.length > 0 ? targets : [{ id: worktreeId }]
       })
-      const purgeState = purgeTargets.length > 0 ? buildWorktreePurgeState(s, purgeTargets) : {}
+      // Why keep drafts: a removed or re-paired environment's sessions live on its host and can be
+      // published again; losing contact with a host is not proof its chats ended.
+      const purgeState =
+        purgeTargets.length > 0
+          ? buildWorktreePurgeState(s, purgeTargets, { keepChatDrafts: true })
+          : {}
       const visitPurgeTargets = [
         ...removedWorktreeTargets,
         ...purgeTargets.filter(
diff --git a/src/renderer/src/store/slices/worktrees/teardown/removed-worktree-renderer-teardown.ts b/src/renderer/src/store/slices/worktrees/teardown/removed-worktree-renderer-teardown.ts
index ab8309338c5..49c9fa612f6 100644
--- a/src/renderer/src/store/slices/worktrees/teardown/removed-worktree-renderer-teardown.ts
+++ b/src/renderer/src/store/slices/worktrees/teardown/removed-worktree-renderer-teardown.ts
@@ -6,6 +6,7 @@ import { appliedWorktreeCatalogVersionPatch } from '../listing/worktree-catalog-
 import { cleanupEphemeralVmRuntimesForDeleted } from '@/lib/ephemeral-vm-runtime-cleanup'
 import { forgetAgentStartupDeliveriesForTabs } from '@/lib/agent-startup-delivery-guards'
 import { forgetForegroundTerminalTabs } from '@/lib/foreground-terminal-tabs'
+import { discardNativeChatDrafts } from '@/components/native-chat/native-chat-draft-cache'
 import { requestVirtualizedScrollAnchorRecord } from '@/hooks/requestVirtualizedScrollAnchorRecord'
 import { disposeRemovedWorktreeParkedTerminalWatchers } from '../../../../components/terminal-pane/terminal-parked-watcher-registry'
 import { detachedHeadAutoDerivedDisplayNames } from '../metadata/detached-head-display-name'
@@ -79,6 +80,8 @@ export async function tearDownRemovedWorktreeRendererState(args: {
   detachedHeadAutoDerivedDisplayNames.delete(worktreeId)
   forgetForegroundTerminalTabs(tabIds)
   forgetAgentStartupDeliveriesForTabs(tabIds)
+  // The worktree is deleted, so its terminal-agent chats ended with it.
+  discardNativeChatDrafts({ terminalTabIds: tabIds })
 
   // Why: snapshot the sidebar top-row anchor in the same tick we remove the row; recording at click time goes stale across the await.
   requestVirtualizedScrollAnchorRecord('[data-worktree-sidebar]')
diff --git a/src/renderer/src/store/slices/worktrees/teardown/worktree-purge-state.ts b/src/renderer/src/store/slices/worktrees/teardown/worktree-purge-state.ts
index 31ef6cda2e3..c26ed928d55 100644
--- a/src/renderer/src/store/slices/worktrees/teardown/worktree-purge-state.ts
+++ b/src/renderer/src/store/slices/worktrees/teardown/worktree-purge-state.ts
@@ -15,13 +15,18 @@ import {
   structuredLaunchStates
 } from '@/lib/structured-agent-session-launch-registry'
 import { discardStructuredAgentSessionLaunchOutbox } from '@/components/native-chat/structured-agent-session-outbox-storage'
+import { discardNativeChatDrafts } from '@/components/native-chat/native-chat-draft-cache'
 import { clearWebSessionFocusIntentIfMatches } from '@/runtime/web-session-focus-intent'
 import { LOCAL_STRUCTURED_SESSION_OWNER } from '@/runtime/local-structured-session-owner'
 
 /** Builds a bulk cleanup patch and clears auxiliary warning records without requiring individual terminal teardown. */
 export function buildWorktreePurgeState(
   s: AppState,
-  worktreeTargets: WorktreePurgeTargets
+  worktreeTargets: WorktreePurgeTargets,
+  options: {
+    /** The worktrees' host binding went away, not their chats, which may come back with it. */
+    keepChatDrafts?: boolean
+  } = {}
 ): Partial<AppState> {
   const normalizedTargets: WorktreePurgeTarget[] = worktreeTargets.map((target) =>
     typeof target === 'string' ? { id: target } : target
@@ -45,8 +50,12 @@ export function buildWorktreePurgeState(
       cancelledSessionIds.add(launch.intent.sessionId)
     }
   }
+  const endedSessionIds = new Set(cancelledSessionIds)
   for (const worktreeId of worktreeIdSet) {
     for (const tab of s.unifiedTabsByWorktree[worktreeId] ?? []) {
+      if (tab.contentType === 'agent-session') {
+        endedSessionIds.add(tab.entityId)
+      }
       if (
         tab.contentType === 'agent-session' &&
         !cancelledSessionIds.has(tab.entityId) &&
@@ -72,6 +81,9 @@ export function buildWorktreePurgeState(
   forgetAmbiguousOwnerWarnings(worktreeIdSet)
 
   const doomed = collectWorktreePurgeDoomedIds(s, worktreeIdSet)
+  if (!options.keepChatDrafts) {
+    discardNativeChatDrafts({ sessionIds: endedSessionIds, terminalTabIds: doomed.doomedTabIds })
+  }
   const {
     omitByWorktree,
     omitWorkspaceLineageByWorktree,
diff --git a/src/renderer/src/store/terminals/terminal-ephemeral-state.ts b/src/renderer/src/store/terminals/terminal-ephemeral-state.ts
index 80de6b6899a..f0ac24de139 100644
--- a/src/renderer/src/store/terminals/terminal-ephemeral-state.ts
+++ b/src/renderer/src/store/terminals/terminal-ephemeral-state.ts
@@ -1,6 +1,7 @@
 import { isClaudeAgent } from '@/lib/agent-status'
 import { recordTerminalInputActivity } from '@/lib/terminal-input-activity-coalescing'
 import { classifyTitleActivity } from '@/lib/pane-agent-evidence'
+import { forgetNativeChatTuiInputSeeds } from '@/components/native-chat/native-chat-draft-cache'
 import type { TerminalSlice, TerminalStoreGet, TerminalStoreSet } from './terminal-state'
 
 export function createTerminalEphemeralActions(
@@ -132,6 +133,8 @@ export function createTerminalEphemeralActions(
       })
     },
     clearNativeChatLaunchDraft: (tabId) => {
+      // The draft's saved copy of the seed goes with it, or a relaunch would seed it again.
+      forgetNativeChatTuiInputSeeds(tabId)
       set((s) => {
         if (!s.nativeChatLaunchDraftByTabId[tabId]) {
           return s
diff --git a/src/renderer/src/store/terminals/terminal-tab-close-map-identity.test.ts b/src/renderer/src/store/terminals/terminal-tab-close-map-identity.test.ts
index 1b44147ca30..ebf5cad79c1 100644
--- a/src/renderer/src/store/terminals/terminal-tab-close-map-identity.test.ts
+++ b/src/renderer/src/store/terminals/terminal-tab-close-map-identity.test.ts
@@ -2,6 +2,13 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'
 import type * as AgentStatusModule from '@/lib/agent-status'
 import { createTestStore, makeTab, makeWorktree, seedStore } from '../slices/store-test-helpers'
 import { createStoreCascadesMockApi } from '../slices/store-cascades-test-harness'
+import {
+  appendNativeChatDraftNow,
+  nativeChatDraftKey,
+  readNativeChatDraftCache,
+  readNativeChatDraftTuiInputSeed,
+  writeNativeChatDraftTuiInputSeed
+} from '@/components/native-chat/native-chat-draft-cache'
 
 vi.mock('sonner', () => ({
   toast: { info: vi.fn(), success: vi.fn(), error: vi.fn(), warning: vi.fn() }
@@ -108,3 +115,31 @@ describe('closeTab map identity', () => {
     expect(after.unreadTerminalPanes).toEqual({})
   })
 })
+
+describe('closeTab and chat drafts', () => {
+  it("deletes the chat drafts of the closing tab's panes only", () => {
+    const store = storeWithTwoTabs()
+    const closing = nativeChatDraftKey({ paneKey: 'tab-a:leaf-1' })
+    const kept = nativeChatDraftKey({ paneKey: 'tab-b:leaf-1' })
+    appendNativeChatDraftNow(closing, { text: 'unsent' })
+    appendNativeChatDraftNow(kept, { text: 'unsent' })
+
+    store.getState().closeTab('tab-a')
+
+    expect(readNativeChatDraftCache(closing)).toBe('')
+    expect(readNativeChatDraftCache(kept)).toBe('unsent')
+  })
+})
+
+describe('clearing a tab launch draft', () => {
+  // Sent, resolved or closed: the input line no longer holds it, so a relaunch must not seed it.
+  it("forgets the seed its panes' drafts saved", () => {
+    const store = storeWithTwoTabs()
+    const pane = nativeChatDraftKey({ paneKey: 'tab-a:leaf-1' })
+    writeNativeChatDraftTuiInputSeed(pane, { agent: 'claude', text: 'issue', createdAt: 1 })
+
+    store.getState().clearNativeChatLaunchDraft('tab-a')
+
+    expect(readNativeChatDraftTuiInputSeed(pane)).toBeUndefined()
+  })
+})
diff --git a/src/renderer/src/store/terminals/terminal-tab-close.ts b/src/renderer/src/store/terminals/terminal-tab-close.ts
index 8227521d2ec..9388b4e9a46 100644
--- a/src/renderer/src/store/terminals/terminal-tab-close.ts
+++ b/src/renderer/src/store/terminals/terminal-tab-close.ts
@@ -7,6 +7,7 @@ import {
 } from '../slices/recently-closed-tabs'
 // Why: use the store-free registry (not terminal-parked-tab-watchers, which imports @/store) to avoid re-entering store creation during this slice's eval.
 import { retireParkedTerminalTab } from '@/components/terminal-pane/terminal-parked-watcher-registry'
+import { discardNativeChatDrafts } from '@/components/native-chat/native-chat-draft-cache'
 import {
   buildTerminalTabRetirementPlan,
   removeSleepingAgentSessionsForTab
@@ -35,6 +36,8 @@ export function createTerminalTabCloseActions(
       let closingWorktreeId: string | null = null
       // Why: a parked tab has no mounted TerminalPane cleanup, so revoke its observer/candidate state before provider exit races.
       retireParkedTerminalTab(tabId)
+      // Why: a reopened tab gets a new id, so its panes' chat drafts are unreachable.
+      discardNativeChatDrafts({ terminalTabIds: [tabId] })
       if (retiresSession) {
         startTerminalTabProviderRetirement({
           localPtyTeardownOwnedExternally: opts?.localPtyTeardownOwnedExternally === true,
diff --git a/src/renderer/src/web/preload-api/web-native-chat-api.ts b/src/renderer/src/web/preload-api/web-native-chat-api.ts
index 746236330f9..69e10190ce6 100644
--- a/src/renderer/src/web/preload-api/web-native-chat-api.ts
+++ b/src/renderer/src/web/preload-api/web-native-chat-api.ts
@@ -7,9 +7,11 @@ import {
 import { translate } from '@/i18n/i18n'
 import { callRuntimeResult } from './web-runtime-calls'
 import { getClientForEnvironment, requireActiveEnvironmentOrNull } from './web-runtime-session'
+import { createWebNativeChatDrafts } from './web-native-chat-drafts'
 
 export function createWebNativeChatApi(): NativeChatApi {
   return {
+    drafts: createWebNativeChatDrafts(),
     readSession: async (agent, sessionId, limit, transcriptPath) =>
       parseRuntimeNativeChatReadSessionResult(
         await callRuntimeResult<unknown>('nativeChat.readSession', {
diff --git a/src/renderer/src/web/preload-api/web-native-chat-drafts.test.ts b/src/renderer/src/web/preload-api/web-native-chat-drafts.test.ts
new file mode 100644
index 00000000000..35b69dbfb8b
--- /dev/null
+++ b/src/renderer/src/web/preload-api/web-native-chat-drafts.test.ts
@@ -0,0 +1,85 @@
+// @vitest-environment happy-dom
+// The web client keeps its drafts in this browser, never on the runtime it is paired with.
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { callRuntimeResultMock, getClientForEnvironmentMock } = vi.hoisted(() => ({
+  callRuntimeResultMock: vi.fn(),
+  getClientForEnvironmentMock: vi.fn()
+}))
+
+vi.mock('./web-runtime-calls', () => ({ callRuntimeResult: callRuntimeResultMock }))
+vi.mock('./web-runtime-session', () => ({
+  getClientForEnvironment: getClientForEnvironmentMock,
+  requireActiveEnvironmentOrNull: vi.fn(() => null)
+}))
+
+import { createWebNativeChatApi } from './web-native-chat-api'
+
+const PREFIX = 'orca:nativeChatComposerDraft:v1:'
+const draft = { text: 'half typed', attachments: [] }
+
+beforeEach(() => localStorage.clear())
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+  vi.clearAllMocks()
+})
+
+describe('web client drafts', () => {
+  it('saves, loads and clears drafts in browser storage only', async () => {
+    const { drafts } = createWebNativeChatApi()
+
+    await expect(drafts.write('session:s1', draft)).resolves.toBe('persisted')
+    expect(
+      JSON.parse(localStorage.getItem(`${PREFIX}${encodeURIComponent('session:s1')}`) ?? 'null')
+    ).toMatchObject(draft)
+    expect(await drafts.load()).toEqual([{ scopeKey: 'session:s1', draft }])
+    expect(drafts.loadSync()).toEqual([{ scopeKey: 'session:s1', draft }])
+
+    await drafts.write('session:s1', null)
+    expect(localStorage.length).toBe(0)
+    expect(callRuntimeResultMock).not.toHaveBeenCalled()
+    expect(getClientForEnvironmentMock).not.toHaveBeenCalled()
+  })
+
+  it('reports a write the browser refused', async () => {
+    vi.stubGlobal('localStorage', {
+      ...localStorage,
+      setItem: () => {
+        throw new DOMException('quota', 'QuotaExceededError')
+      }
+    })
+
+    await expect(createWebNativeChatApi().drafts.write('session:s1', draft)).resolves.toBe('failed')
+  })
+
+  // Blocked site storage is a setting, not an error.
+  it('reports no storage, rather than a failure, when the browser has none', async () => {
+    vi.stubGlobal('localStorage', undefined)
+
+    await expect(createWebNativeChatApi().drafts.write('session:s1', draft)).resolves.toBe(
+      'unavailable'
+    )
+  })
+
+  it("hears another tab's change to a draft", () => {
+    const listener = vi.fn()
+    createWebNativeChatApi().drafts.onExternalChange?.(listener)
+
+    window.dispatchEvent(
+      new StorageEvent('storage', {
+        key: `${PREFIX}${encodeURIComponent('pane:tab-1:leaf-1')}`,
+        newValue: JSON.stringify({ ...draft, savedAt: 1 })
+      })
+    )
+    window.dispatchEvent(
+      new StorageEvent('storage', { key: `${PREFIX}${encodeURIComponent('session:s1')}` })
+    )
+
+    expect(listener.mock.calls).toEqual([
+      ['pane:tab-1:leaf-1', draft],
+      ['session:s1', null]
+    ])
+  })
+})
diff --git a/src/renderer/src/web/preload-api/web-native-chat-drafts.ts b/src/renderer/src/web/preload-api/web-native-chat-drafts.ts
new file mode 100644
index 00000000000..d0a4db2ad9f
--- /dev/null
+++ b/src/renderer/src/web/preload-api/web-native-chat-drafts.ts
@@ -0,0 +1,110 @@
+import type { NativeChatDraftsApi } from '../../../../preload/api-types'
+import {
+  isEmptyNativeChatDraft,
+  parseNativeChatDraft,
+  type PersistedNativeChatDraft,
+  type SavedNativeChatDraft
+} from '../../../../shared/native-chat-draft-record'
+
+// The web client keeps drafts in this browser's storage, never on the runtime it is paired with.
+// The browser commits storage to disk on its own schedule, so a browser crash right after Enter
+// can still bring a sent draft back; an Orca reload or tab crash cannot.
+const DRAFT_PREFIX = 'orca:nativeChatComposerDraft:v1:'
+const MAX_SAVED_DRAFTS = 128
+
+function storageKey(scopeKey: string): string {
+  return `${DRAFT_PREFIX}${encodeURIComponent(scopeKey)}`
+}
+
+function draftStorage(): Storage | null {
+  try {
+    return globalThis.localStorage ?? null
+  } catch {
+    return null
+  }
+}
+
+function parseStoredDraft(
+  raw: string | null
+): { draft: PersistedNativeChatDraft; savedAt: number } | null {
+  try {
+    const value: unknown = raw ? JSON.parse(raw) : null
+    const draft = parseNativeChatDraft(value)
+    const savedAt =
+      typeof value === 'object' && value !== null && 'savedAt' in value ? value.savedAt : 0
+    return draft ? { draft, savedAt: typeof savedAt === 'number' ? savedAt : 0 } : null
+  } catch {
+    return null
+  }
+}
+
+/** Reads every saved draft, oldest first; unreadable ones and those past the cap are deleted. */
+function loadDrafts(): SavedNativeChatDraft[] {
+  const storage = draftStorage()
+  if (!storage) {
+    return []
+  }
+  try {
+    const loaded: (SavedNativeChatDraft & { savedAt: number })[] = []
+    const discarded: string[] = []
+    for (let index = 0; index < storage.length; index += 1) {
+      const key = storage.key(index)
+      if (!key?.startsWith(DRAFT_PREFIX)) {
+        continue
+      }
+      const saved = parseStoredDraft(storage.getItem(key))
+      if (saved) {
+        loaded.push({ scopeKey: decodeURIComponent(key.slice(DRAFT_PREFIX.length)), ...saved })
+      } else {
+        discarded.push(key)
+      }
+    }
+    loaded.sort((left, right) => left.savedAt - right.savedAt)
+    const kept = loaded.slice(Math.max(0, loaded.length - MAX_SAVED_DRAFTS))
+    for (const { scopeKey } of loaded.slice(0, loaded.length - kept.length)) {
+      discarded.push(storageKey(scopeKey))
+    }
+    discarded.forEach((key) => storage.removeItem(key))
+    return kept.map(({ scopeKey, draft }) => ({ scopeKey, draft }))
+  } catch {
+    return []
+  }
+}
+
+export function createWebNativeChatDrafts(): NativeChatDraftsApi {
+  return {
+    savesSendClearAtOnce: true,
+    load: async () => loadDrafts(),
+    loadSync: loadDrafts,
+    write: async (scopeKey, draft) => {
+      const storage = draftStorage()
+      if (!storage) {
+        return 'unavailable'
+      }
+      try {
+        if (!draft || isEmptyNativeChatDraft(draft)) {
+          storage.removeItem(storageKey(scopeKey))
+        } else {
+          storage.setItem(storageKey(scopeKey), JSON.stringify({ ...draft, savedAt: Date.now() }))
+        }
+        return 'persisted'
+      } catch {
+        return 'failed'
+      }
+    },
+    onExternalChange: (listener) => {
+      if (typeof window === 'undefined' || typeof window.addEventListener !== 'function') {
+        return
+      }
+      // Another tab of this origin wrote; a tab never hears its own writes.
+      window.addEventListener('storage', (event) => {
+        if (event.key?.startsWith(DRAFT_PREFIX)) {
+          listener(
+            decodeURIComponent(event.key.slice(DRAFT_PREFIX.length)),
+            parseStoredDraft(event.newValue)?.draft ?? null
+          )
+        }
+      })
+    }
+  }
+}
diff --git a/src/shared/native-chat-draft-record.test.ts b/src/shared/native-chat-draft-record.test.ts
new file mode 100644
index 00000000000..e00dc9b3e82
--- /dev/null
+++ b/src/shared/native-chat-draft-record.test.ts
@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import { isEmptyNativeChatDraft, parseNativeChatDraft } from './native-chat-draft-record'
+
+describe("a saved draft's held sends", () => {
+  it('keeps each one with its id, text, images and time, ignoring fields a newer build added', () => {
+    expect(
+      parseNativeChatDraft({
+        text: '',
+        attachments: [],
+        heldSends: [
+          {
+            clientMessageId: 'm1',
+            text: 'sent once',
+            attachments: [{ id: 'a1', path: '/a.png', location: 'local' }],
+            sentAt: 5,
+            fromNewerBuild: true
+          }
+        ]
+      })
+    ).toEqual({
+      text: '',
+      attachments: [],
+      heldSends: [
+        {
+          clientMessageId: 'm1',
+          text: 'sent once',
+          attachments: [{ id: 'a1', path: '/a.png', location: 'local' }],
+          sentAt: 5
+        }
+      ]
+    })
+  })
+
+  it('drops an entry with no id or no text, and keeps the draft only while something is left', () => {
+    expect(
+      parseNativeChatDraft({
+        text: '',
+        attachments: [],
+        heldSends: [{ text: 'no id' }, { clientMessageId: 'm2' }, 'junk']
+      })
+    ).toBeNull()
+  })
+
+  it('counts a box emptied by a send that is still held as worth saving', () => {
+    expect(
+      isEmptyNativeChatDraft({
+        text: '',
+        attachments: [],
+        heldSends: [{ clientMessageId: 'm1', text: 'sent once', attachments: [], sentAt: 5 }]
+      })
+    ).toBe(false)
+  })
+})
diff --git a/src/shared/native-chat-draft-record.ts b/src/shared/native-chat-draft-record.ts
new file mode 100644
index 00000000000..1e037699450
--- /dev/null
+++ b/src/shared/native-chat-draft-record.ts
@@ -0,0 +1,162 @@
+// One chat's unsent composer content as it is saved: by the main process on desktop, in browser
+// storage in the web client. Parsed the same way in both, so a damaged record is dropped, not trusted.
+
+import type { TuiAgent } from './tui-agent'
+import { isTuiAgent } from './tui-agent-config'
+
+/**
+ * Where an image's file lives: on this machine, on an SSH host (`connectionId`), or on a runtime
+ * server. Chips saved before this was recorded have none, and are treated as unknown.
+ */
+export type NativeChatDraftAttachmentLocation = 'local' | 'ssh' | 'runtime'
+
+export type NativeChatDraftAttachment = {
+  id: string
+  path: string
+  connectionId?: string
+  location?: NativeChatDraftAttachmentLocation
+}
+
+/** Launch text Orca typed into a terminal agent's input line, which still holds it. */
+export type NativeChatTuiInputSeed = { agent: TuiAgent; text: string; createdAt: number }
+
+/**
+ * A message sent from this box that the host may not hold yet: kept beside the live draft from
+ * Enter until the host holds it, so a crash in between can still give it back. After a relaunch it
+ * goes back into the box unless the host holds it by then.
+ */
+export type NativeChatHeldSend = {
+  /** The send's id, which the host's submission or queued card carries. */
+  clientMessageId: string
+  text: string
+  attachments: readonly NativeChatDraftAttachment[]
+  /** When it was sent. */
+  sentAt: number
+}
+
+export type PersistedNativeChatDraft = {
+  text: string
+  attachments: readonly NativeChatDraftAttachment[]
+  tuiInputSeed?: NativeChatTuiInputSeed
+  /** Outbox entries already moved into this draft, so a crash before the outbox drops them never
+   *  imports them twice. Kept as read; written by the outbox importer. */
+  importedOutboxEntryIds?: readonly string[]
+  /** Sends from this box the host may not hold yet, oldest first. */
+  heldSends?: readonly NativeChatHeldSend[]
+}
+
+/** One saved draft and the chat it belongs to. */
+export type SavedNativeChatDraft = { scopeKey: string; draft: PersistedNativeChatDraft }
+
+/**
+ * The outcome of a write; `failed` and `unavailable` leave the draft in memory only. `unavailable`
+ * means there is no storage to write to (a browser with site storage blocked), not an error.
+ */
+export type NativeChatDraftStoreResult = 'persisted' | 'failed' | 'unavailable'
+
+export function isEmptyNativeChatDraft(draft: PersistedNativeChatDraft): boolean {
+  return (
+    draft.text === '' &&
+    draft.attachments.length === 0 &&
+    !draft.tuiInputSeed &&
+    !draft.importedOutboxEntryIds?.length &&
+    !draft.heldSends?.length
+  )
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+const ATTACHMENT_LOCATIONS: readonly unknown[] = ['local', 'ssh', 'runtime']
+
+function isAttachmentLocation(value: unknown): value is NativeChatDraftAttachmentLocation {
+  return ATTACHMENT_LOCATIONS.includes(value)
+}
+
+function parseAttachment(value: unknown): NativeChatDraftAttachment | null {
+  if (!isRecord(value)) {
+    return null
+  }
+  const { id, path, connectionId, location } = value
+  if (typeof id !== 'string' || typeof path !== 'string' || path === '') {
+    return null
+  }
+  return {
+    id,
+    path,
+    ...(typeof connectionId === 'string' ? { connectionId } : {}),
+    ...(isAttachmentLocation(location) ? { location } : {})
+  }
+}
+
+function parseTuiInputSeed(value: unknown): { tuiInputSeed?: NativeChatTuiInputSeed } {
+  if (!isRecord(value)) {
+    return {}
+  }
+  const { agent, text, createdAt } = value
+  return isTuiAgent(agent) &&
+    typeof text === 'string' &&
+    text !== '' &&
+    typeof createdAt === 'number'
+    ? { tuiInputSeed: { agent, text, createdAt } }
+    : {}
+}
+
+function parseAttachments(value: unknown[]): NativeChatDraftAttachment[] {
+  return value
+    .map(parseAttachment)
+    .filter((attachment): attachment is NativeChatDraftAttachment => attachment !== null)
+}
+
+// Fields a newer build adds are ignored; an entry missing its id or text is dropped.
+function parseHeldSends(value: unknown): { heldSends?: NativeChatHeldSend[] } {
+  if (!Array.isArray(value)) {
+    return {}
+  }
+  const heldSends = value.flatMap((entry): NativeChatHeldSend[] => {
+    if (!isRecord(entry)) {
+      return []
+    }
+    const { clientMessageId, text, attachments, sentAt } = entry
+    if (typeof clientMessageId !== 'string' || clientMessageId === '' || typeof text !== 'string') {
+      return []
+    }
+    return [
+      {
+        clientMessageId,
+        text,
+        attachments: Array.isArray(attachments) ? parseAttachments(attachments) : [],
+        sentAt: typeof sentAt === 'number' ? sentAt : 0
+      }
+    ]
+  })
+  return heldSends.length > 0 ? { heldSends } : {}
+}
+
+function parseImportedOutboxEntryIds(value: unknown): { importedOutboxEntryIds?: string[] } {
+  if (!Array.isArray(value)) {
+    return {}
+  }
+  const ids = value.filter((id): id is string => typeof id === 'string')
+  return ids.length > 0 ? { importedOutboxEntryIds: ids } : {}
+}
+
+/** A saved draft from untrusted bytes; null when unreadable or empty. */
+export function parseNativeChatDraft(value: unknown): PersistedNativeChatDraft | null {
+  if (!isRecord(value)) {
+    return null
+  }
+  const { text, attachments, tuiInputSeed, importedOutboxEntryIds, heldSends } = value
+  if (typeof text !== 'string' || !Array.isArray(attachments)) {
+    return null
+  }
+  const draft = {
+    text,
+    attachments: parseAttachments(attachments),
+    ...parseTuiInputSeed(tuiInputSeed),
+    ...parseImportedOutboxEntryIds(importedOutboxEntryIds),
+    ...parseHeldSends(heldSends)
+  }
+  return isEmptyNativeChatDraft(draft) ? null : draft
+}