dsh-code 1.2.0 → 1.3.0

package/src/attachments.ts

@@ -52,17 +52,41 @@ export function looksLikeImagePath(path: string): boolean {
   return IMAGE_EXTENSIONS.has(extname(path).toLowerCase())
 }
 
+/** Strip one layer of ASCII or Unicode quotes and shell-escaped spaces. */
+export function unwrapDroppedPath(token: string): string {
+  const trimmed = token.trim()
+  const wrapped = /^[\u2018\u201C"'](.+)[\u2019\u201D"']$/u.exec(trimmed)
+  return (wrapped?.[1] ?? trimmed).replace(/\\ /gu, ' ')
+}
+
+/** Absolute/relative drop with a dotted leaf — including unquoted spaces. */
+export function looksLikeFilesystemDrop(path: string): boolean {
+  if (path.startsWith('file://')) return true
+  if (!/^(?:\/|[A-Za-z]:[\\/]|\\\\|\.\.?\/)/u.test(path)) return false
+  return looksLikeImagePath(path) || /\.[A-Za-z0-9]{1,16}$/u.test(path)
+}
+
 /**
- * Parse a paste/drop into its image and file paths: image-suffixed tokens
- * stay images, other path-shaped tokens ride as file attachments (0.1.5
- * file blocks), and anything that is neither leaves both empty — the caller
- * then treats the paste as plain text.
+ * A composer draft that is a filesystem path, not a slash command.
+ * `/usage` stays a command; `/Users/foo.png` and `C:\temp\a.png` are drops.
+ */
+export function looksLikePathDraft(value: string): boolean {
+  const path = unwrapDroppedPath(value)
+  if (looksLikeFilesystemDrop(path)) return true
+  return /^\/(?:Users|home|tmp|var|etc|opt|mnt|Volumes)\//u.test(path)
+}
+
+/**
+ * Parse a paste or file-drop into image and file paths: image-suffixed
+ * tokens stay images, other path-shaped tokens ride as file attachments
+ * (0.1.5 file blocks), and anything that is neither leaves both empty —
+ * the caller then treats the paste as plain text.
  *
  * File tokens are held to an absolute-path-with-shape bar (drive/backslash
- * or a dot-suffixed leaf after a separator): a dropped terminal path always
+ * or a dotted leaf after a separator): a dropped terminal path always
  * carries one of those, while prose, slash commands, and option flags never
- * do. A POSIX absolute path without any dot-suffixed leaf falls through as
- * text — the @ mention route still attaches such files deliberately.
+ * do. A POSIX absolute path without a dotted leaf falls through as text —
+ * the @ mention route still attaches such files deliberately.
  */
 export function parsePastedAttachmentPaths(input: string): { readonly images: readonly string[]; readonly files: readonly string[] } {
   const text = input.trim()
@@ -73,27 +97,49 @@ export function parsePastedAttachmentPaths(input: string): { readonly images: re
     /^[A-Za-z]:[\\/]/u.test(path)
     || /^\\\\/u.test(path)
     || (/^\/|^\.\.?\//u.test(path) && /\.[A-Za-z0-9]{1,16}$/u.test(path))
-  const matcher = /"([^"]+)"|'([^']+)'|(\S+)/gu
-  for (const match of text.matchAll(matcher)) {
-    const token = match[1] ?? match[2] ?? match[3]
-    if (token === undefined) continue
-    let path = token
+  const classify = (raw: string): 'image' | 'file' | 'reject' => {
+    let path = unwrapDroppedPath(raw)
     if (path.startsWith('file://')) {
       try {
         path = fileURLToPath(path)
       } catch {
-        return { images: [], files: [] }
+        return 'reject'
+      }
+    } else if (/%[0-9A-Fa-f]{2}/u.test(path)) {
+      try {
+        path = decodeURIComponent(path)
+      } catch {
+        // Keep the raw token when it is not a valid percent-encoding.
       }
-      if (looksLikeImagePath(path)) images.push(path)
-      else files.push(path)
-      continue
     }
     if (looksLikeImagePath(path)) {
       images.push(path)
-      continue
+      return 'image'
+    }
+    if (looksLikeDroppedFile(path) || looksLikeFilesystemDrop(path)) {
+      files.push(path)
+      return 'file'
     }
-    if (!looksLikeDroppedFile(path)) return { images: [], files: [] }
-    files.push(path)
+    return 'reject'
+  }
+  // A single dropped path with spaces often arrives unquoted (macOS, Windows
+  // Explorer, VS Code sendText). Use the whole paste only when there is one
+  // path start and the text actually contains spaces (or wrapping quotes) —
+  // two unquoted `C:\a.png D:\b.txt` tokens must still split.
+  const whole = unwrapDroppedPath(text)
+  const pathStarts = text.match(/(?:^|[\s"'])(?:\/|[A-Za-z]:[\\/]|\\\\|\.\.?\/|file:\/\/)/gu) ?? []
+  const spacedSingleton = pathStarts.length <= 1
+    && looksLikeFilesystemDrop(whole)
+    && (/\s/u.test(whole) || /^[\u2018\u201C"']/u.test(text))
+  if (spacedSingleton) {
+    classify(whole)
+    return { images, files }
+  }
+  const matcher = /"([^"]+)"|'([^']+)'|(\S+)/gu
+  for (const match of text.matchAll(matcher)) {
+    const token = match[1] ?? match[2] ?? match[3]
+    if (token === undefined) continue
+    if (classify(token) === 'reject') return { images: [], files: [] }
   }
   return { images, files }
 }

package/src/authorization-panel.ts

@@ -75,14 +75,17 @@ export function ProviderAuthorizationPanel(props: ProviderAuthorizationPanelProp
     decline()
   }
 
+  const propsRef = useRef(props)
+  propsRef.current = props
+  const rowKey = props.row.key
   useEffect(() => () => {
     controllerRef.current?.abort()
-    props.cancel(props.row.key)
+    propsRef.current.cancel(rowKey)
     const reply = replyRef.current
     replyRef.current = undefined
     reply?.detach()
     reply?.reject(new AuthorizationDeclinedError())
-  }, [props.row.key])
+  }, [rowKey])
 
   const start = (method: string): void => {
     setPhase('running')

package/src/fork.ts

@@ -13,13 +13,17 @@ export function selectForkSeed(events: readonly SessionEvent[], atSeq?: number):
     throw new Error('fork event sequence must be a non-negative integer')
   }
   const lastSeq = events.at(-1)?.seq ?? -1
-  const anchored = atSeq === undefined
-    ? undefined
-    : events.find(event => event.type === 'turn/end' && event.seq >= atSeq)
-  const boundary = anchored
-    ?? (atSeq === undefined || atSeq > lastSeq
-      ? events.findLast(event => event.type === 'turn/end')
-      : undefined)
+  let boundary: SessionEvent | undefined
+  if (atSeq === undefined || atSeq > lastSeq) {
+    boundary = events.findLast(event => event.type === 'turn/end')
+  } else {
+    // The last turn/start at or before the anchor. A seq in the gap after a
+    // turn/end (title, compaction) must not walk FORWARD to the next turn.
+    const start = events.findLast(event => event.type === 'turn/start' && event.seq <= atSeq)
+    boundary = start === undefined
+      ? undefined
+      : events.find(event => event.type === 'turn/end' && event.seq >= start.seq)
+  }
   if (boundary === undefined) {
     throw new Error(atSeq !== undefined && atSeq <= lastSeq
       ? `the turn containing event ${atSeq} has not completed`

package/src/history.ts

@@ -122,6 +122,20 @@ export function beginRecall(entries: readonly string[], draft: string): RecallSt
   return { entries, index: null, savedDraft: draft, lastRecalled: null }
 }
 
+/**
+ * Join a panel-recalled entry onto the draft already in the composer: the
+ * draft is extended, never replaced, so picking a history row cannot discard
+ * work in progress. An empty draft takes the entry as-is; otherwise the entry
+ * starts on its own line unless the draft already ends one.
+ * @param draft - the composer text before the recall.
+ * @param entry - the sanitized text of the accepted row.
+ * @returns the text to place in the composer.
+ */
+export function appendRecall(draft: string, entry: string): string {
+  if (draft === '') return entry
+  return draft.endsWith('\n') ? draft + entry : `${draft}\n${entry}`
+}
+
 /** The outcome of one recall step. */
 export interface RecallStep {
   state: RecallState

package/src/index.ts

@@ -25,7 +25,7 @@ import { createUserMessage, MessageId, type ContentBlock } from '@deepseek-ai/ds
 import type { JobSnapshot } from '@deepseek-ai/dsh-jobs'
 import { SessionId, SessionLogOffset, type Session, type SessionEvent, type SessionHeader, type UserMessage } from '@deepseek-ai/dsh-session'
 import { deriveTurnTokenUsage } from '@deepseek-ai/dsh-token-meter/client'
-import type { SessionPersistence } from '@deepseek-ai/dsh-session-persistence'
+import { SessionAlreadyOwnedError, type SessionPersistence } from '@deepseek-ai/dsh-session-persistence'
 // Type-only: carries the ctx.sessionTitle service merge for /title.
 import type {} from '@deepseek-ai/dsh-session-title'
 // Empty type imports carry the loader Context merge for the settlement await
@@ -96,14 +96,17 @@ import { parseAnimationsPref } from './render/animations.ts'
 import { parseThemeName, setTheme, type ThemeName } from './theme.ts'
 import { parseLanguageName, setLanguage, t, type LanguageName } from './i18n.ts'
 import {
+  acquireSessionDeletionLeases,
   isSubagentSession,
   matchSessionId,
   mergeSessionTitles,
   newestRootForCwd,
+  sessionRowMatchesQuery,
   isSessionArtifactName,
   jsonlSessionRoot,
   planSessionDeletion,
   projectSessionRows,
+  releaseSessionDeletionLeases,
   sessionArtifactDirectory,
   sessionDirectoryFor,
   type SessionDirectoryOptions,
@@ -1234,7 +1237,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     try {
       parsed = currentMentions.parse(line)
     } catch (error: unknown) {
-      bridge.notify(`invalid session reference: ${error instanceof Error ? error.message : String(error)}`, 'error')
+      bridge.notify(t('notice.invalidReference', { message: error instanceof Error ? error.message : String(error) }), 'error')
       return
     }
     // Ordered delivery: the inbox order IS the user's message order. A line
@@ -1269,7 +1272,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
         if (mode === 'steer') currentAgent.steer(message)
         else currentAgent.followup(message)
       } catch (error: unknown) {
-        bridge.notify(`${mode === 'steer' ? 'steering' : 'message'} failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+        bridge.notify(t('notice.messageFailed', { kind: mode === 'steer' ? 'steering' : 'message', message: error instanceof Error ? error.message : String(error) }), 'error')
       }
     }
     if (parsed.references.length === 0) {
@@ -1287,7 +1290,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       }, (error: unknown) => {
         pendingControllers.delete(controller)
         if (controller.signal.aborted || epoch !== atEpoch) return
-        bridge.notify(`session reference failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+        bridge.notify(t('notice.referenceFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
       })
     })
   }
@@ -1364,7 +1367,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
           }
           await next.handle.dispose().catch(() => {})
           if (!quitting) renderCurrent()
-          bridge.notify(`session activation failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+          bridge.notify(t('notice.activationFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
           return
         }
         abortPendingControllers()
@@ -1383,7 +1386,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       }
     }).catch((error: unknown) => {
       pendingInputs.length = 0
-      bridge.notify(`session creation failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+      bridge.notify(t('notice.creationFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
     })
   }
 
@@ -1393,19 +1396,27 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     // exact whitespace unless the line is a syntactic slash command.
     const line = submissionPayload(text)
     if (line.trim() === '' && images.length === 0) return
+    // A switch between the idle wait and the handoff keeps the OLD session
+    // installed: a line delivered now would start a turn the handoff discards.
+    // Refusing loudly beats losing it silently — the caller can retry after the
+    // switch, and `switchQueue.cancel()` is the way out.
+    if (switchQueue.activating) {
+      bridge.notify(t('notice.switchInProgress'), 'warning')
+      return
+    }
     if (images.length === 0 && line.startsWith('/mode ')) {
       void switchModeAction(line.slice(6).trim()).then(
-        selected => bridge.notify(`mode → ${selected}`),
-        error => bridge.notify(`mode switch failed: ${error instanceof Error ? error.message : String(error)}`, 'error'),
+        selected => bridge.notify(t('notice.modeChanged', { value: selected })),
+        error => bridge.notify(t('notice.modeChangeFailed', { message: error instanceof Error ? error.message : String(error) }), 'error'),
       )
       return
     }
     if (images.length === 0 && line.startsWith('/permission ')) {
       try {
         const selected = setPermissionAction(line.slice(12).trim())
-        bridge.notify(`permission → ${selected}`)
+        bridge.notify(t('notice.permissionChanged', { value: selected }))
       } catch (error: unknown) {
-        bridge.notify(`permission change failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+        bridge.notify(t('notice.permissionChangeFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
       }
       return
     }
@@ -1458,7 +1469,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       bridge.notify(t(preserved > 0 ? 'notice.turnCancelledKeepQueue' : 'notice.turnCancelled'))
       return true
     } catch (error: unknown) {
-      bridge.notify(`cancel failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+      bridge.notify(t('notice.cancelFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
       return false
     }
   }
@@ -1491,7 +1502,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
    */
   const cycleMode = (): string => {
     if (permissionPresets === undefined || permissionPresets.names.length === 0) {
-      bridge.notify('permission presets are not mounted in this composition', 'warning')
+      bridge.notify(t('notice.permissionPresetsUnmounted'), 'warning')
       return ''
     }
     try {
@@ -1542,7 +1553,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       selectPermission(permissionPresets, session, decision.preset)
       return `plan → off · permission → ${decision.preset}`
     } catch (error: unknown) {
-      bridge.notify(`mode change failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+      bridge.notify(t('notice.modeChangeFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
       return ''
     }
   }
@@ -1568,7 +1579,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     // it. Save failures degrade to a notice — the in-session switch already
     // took effect and must not roll back (the web contract).
     void defaultModel.saveSelection(selection).catch((error: unknown) => {
-      bridge.notify(`model switch applies to this session but was not saved as the default: ${error instanceof Error ? error.message : String(error)}`, 'warning')
+      bridge.notify(t('notice.modelNotDefault', { message: error instanceof Error ? error.message : String(error) }), 'warning')
     })
     // Advisory immediate validation (web selectModel parity): run the same
     // local resolveCallConfig check the request pipeline would, so a stale
@@ -1587,7 +1598,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
         model: selection.model,
         ...selection.reasoningEffort === undefined ? {} : { reasoningEffort: selection.reasoningEffort },
       })).catch((error: unknown) => {
-        bridge.notify(`model selection rejected: ${error instanceof Error ? error.message : String(error)} — reopen /model to pick again`, 'error')
+        bridge.notify(t('notice.modelSelectionRejected', { message: error instanceof Error ? error.message : String(error) }), 'error')
       })
     }
     return `${row.provider}/${row.model}`
@@ -1616,7 +1627,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
    */
   const exportTranscript = async (argument: string): Promise<void> => {
     if (session === undefined) {
-      bridge.notify('no session yet — submit a message to start', 'warning')
+      bridge.notify(t('notice.noSessionYet'), 'warning')
       return
     }
     const wanted = argument.trim()
@@ -1633,9 +1644,9 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     const markdown = buildExportMarkdown(store.getView(), session.id)
     try {
       await writeFileAsync(target, `${markdown}\n`, 'utf8')
-      bridge.notify(`exported to ${target}`)
+      bridge.notify(t('notice.exported', { path: target }))
     } catch (error: unknown) {
-      bridge.notify(`export failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+      bridge.notify(t('notice.exportFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
     }
   }
 
@@ -1684,13 +1695,15 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
         }
       }))
     }
-    const projected = projectSessionRows(records, options, updated)
-    // Titles are the expensive fold. Fetch only the first bounded picker page;
-    // navigation/filter changes trigger a fresh, cancellable observation.
-    const page = projected.slice(0, 32)
+    const projected = projectSessionRows(records, { ...options, query: '' }, updated)
+    // Titles are the expensive fold. Fetch the first picker page when idle;
+    // a non-empty query loads more so the displayed title can match.
+    const titleBudget = options.query.trim() === '' ? 32 : Math.min(projected.length, 128)
+    const page = projected.slice(0, titleBudget)
     if (page.length === 0) return projected
     const observations = await sessionQuery.readTitleSnapshots(page.map(row => row.id), signal)
-    return mergeSessionTitles(projected, observations)
+    const titled = mergeSessionTitles(projected, observations)
+    return titled.filter(row => sessionRowMatchesQuery(row, options.query))
   }
 
   /**
@@ -1708,9 +1721,12 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
    *    Backends without a derivable artifact (non-JSONL) refuse the WHOLE
    *    deletion here — no file has been touched yet, so a backend or layout
    *    surprise can never strand a half-deleted subtree.
-   * 3. Artifacts are removed children-first: only an I/O error mid-delete
-   *    can stop it short (reported with removed/total counts), leaving the
-   *    shallowest lineage intact.
+   * 3. Acquire every node's public persistence write handle before touching
+   *    files. The JSONL backend holds its cross-process kernel lease for each
+   *    handle, so another terminal's live session refuses the whole deletion.
+   * 4. Artifacts are removed children-first while every lease remains held:
+   *    only an I/O error mid-delete can stop it short (reported with
+   *    removed/total counts), leaving the shallowest lineage intact.
    *
    * @param id - the root session id to delete.
    * @returns the outcome line for the panel/notice.
@@ -1725,7 +1741,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     // layout-check every node up front, so a refusal never leaves a
     // partially removed subtree behind.
     const root = jsonlSessionRoot(persistence)
-    if (root === undefined) {
+    if (root === undefined || persistence === undefined) {
       return 'session backend exposes no deletable artifact (deletion is unsupported on this backend)'
     }
     const byId = new Map<string, (typeof records)[number]>(records.map(record => [record.header.id, record]))
@@ -1739,14 +1755,25 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       }
       dirs.set(node.id, dir)
     }
+    let leases
+    try {
+      leases = await acquireSessionDeletionLeases(persistence, plan.nodes.map(node => node.id))
+    } catch (error: unknown) {
+      if (error instanceof SessionAlreadyOwnedError) {
+        return `cannot delete ${error.sessionId.slice(-12)} — it is open in this or another process`
+      }
+      return `cannot safely lock sessions for deletion: ${error instanceof Error ? error.message : String(error)}`
+    }
+
     let removed = 0
+    let outcome: string | undefined
     for (const node of plan.nodes) {
       const dir = dirs.get(node.id)!
       try {
         // Remove every canonical generation artifact this build knows; other
-        // sibling files are never ours to delete, and the directory itself is
-        // only removed once empty. An unreadable directory counts as a
-        // failure (not a silent success) so the outcome line stays honest.
+        // sibling files are never ours to delete. The POSIX session.lock file
+        // deliberately remains because unlinking a held flock inode would
+        // forfeit the backend's exclusion guarantee.
         const entries = await readdir(dir, { withFileTypes: true })
         for (const entry of entries) {
           if (entry.isFile() && isSessionArtifactName(entry.name)) {
@@ -1756,10 +1783,17 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
         await rm(dir, { force: true, recursive: false }).catch(() => {})
         removed += 1
       } catch (error: unknown) {
-        return `delete failed for ${node.id.slice(-12)} after ${removed} of ${plan.nodes.length}: ${error instanceof Error ? error.message : String(error)}`
+        outcome = `delete failed for ${node.id.slice(-12)} after ${removed} of ${plan.nodes.length}: ${error instanceof Error ? error.message : String(error)}`
+        break
       }
     }
-    return `deleted ${removed} session${removed === 1 ? '' : 's'}`
+    outcome ??= `deleted ${removed} session${removed === 1 ? '' : 's'}`
+    try {
+      await releaseSessionDeletionLeases(leases)
+    } catch (error: unknown) {
+      return `${outcome}; failed to release deletion locks: ${error instanceof Error ? error.message : String(error)}`
+    }
+    return outcome
   }
 
   const loadSessionTranscript = async (id: string, signal?: AbortSignal): Promise<string> => {
@@ -1906,7 +1940,10 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
         // effect AFTER it, so an immediate notice reaches the UNMOUNTED
         // instance and React drops it silently. Defer past the commit.
         setTimeout(() => {
-          bridge.notify(`${next.resumed ? 'resumed' : 'created'} ${next.session.id.slice(-12)} · mode ${next.mode}`)
+          bridge.notify(t(next.resumed ? 'notice.sessionResumed' : 'notice.sessionCreated', {
+            id: next.session.id.slice(-12),
+            mode: next.mode,
+          }))
         }, 0)
         return
       }
@@ -1914,23 +1951,25 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       try {
         await sessions.flush(previous.session)
       } catch (error: unknown) {
-        cleanupWarning = `previous session flush failed: ${error instanceof Error ? error.message : String(error)}`
+        cleanupWarning = t('notice.flushFailed', { message: error instanceof Error ? error.message : String(error) })
       }
       try {
         await previous.handle.dispose()
       } catch (error: unknown) {
-        cleanupWarning = `${cleanupWarning === undefined ? '' : `${cleanupWarning}; `}previous agent release failed: ${error instanceof Error ? error.message : String(error)}`
+        const release = t('notice.agentReleaseFailed', { message: error instanceof Error ? error.message : String(error) })
+        cleanupWarning = cleanupWarning === undefined ? release : `${cleanupWarning}; ${release}`
       }
+      const shortId = next.session.id.slice(-12)
       bridge.notify(cleanupWarning === undefined
-        ? `${next.resumed ? 'resumed' : 'created'} ${next.session.id.slice(-12)} · mode ${next.mode}`
-        : `switched to ${next.session.id.slice(-12)}, but ${cleanupWarning}`,
+        ? t(next.resumed ? 'notice.sessionResumed' : 'notice.sessionCreated', { id: shortId, mode: next.mode })
+        : t('notice.sessionSwitchedDirty', { id: shortId, detail: cleanupWarning }),
       cleanupWarning === undefined ? 'info' : 'warning')
     })
   }
 
   const switchQueue = new SessionSwitchQueue<PendingSwitch>(
     async request => { if (!quitting) await activate(request.target) },
-    error => bridge.notify(`session switch failed: ${error instanceof Error ? error.message : String(error)}`, 'error'),
+    error => bridge.notify(t('notice.sessionSwitchFailed', { message: error instanceof Error ? error.message : String(error) }), 'error'),
   )
 
   const requestSwitch = (request: PendingSwitch): void => {
@@ -1939,17 +1978,17 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       // the target directly — there is no running turn to wait on and nothing
       // to flush.
       void activate(request.target).catch((error: unknown) => {
-        bridge.notify(`session switch failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+        bridge.notify(t('notice.sessionSwitchFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
       })
       return
     }
     if (request.target.sessionId === session.id) {
-      bridge.notify('that session is already active', 'warning')
+      bridge.notify(t('notice.alreadyActive'), 'warning')
       return
     }
     const outcome = switchQueue.request(agent!, request)
     if (outcome === 'queued') {
-      bridge.notify(`will switch to ${request.label} when the current turn finishes · /resume cancel to abort`)
+      bridge.notify(t('notice.switchQueued', { label: request.label }))
     }
   }
 
@@ -1975,7 +2014,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   const requestResume = (wanted: string): void => {
     void resolveResumeId(wanted).then(id => {
       requestSwitch({ target: { sessionId: id, resume: true }, label: id.slice(-12) })
-    }, (error: unknown) => bridge.notify(`resume failed: ${error instanceof Error ? error.message : String(error)}`, 'error'))
+    }, (error: unknown) => bridge.notify(t('notice.resumeFailed', { message: error instanceof Error ? error.message : String(error) }), 'error'))
   }
 
   const createSession = (mode?: string): void => {
@@ -2039,7 +2078,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
 
   const forkSession = (argument: string): void => {
     if (session === undefined || active === undefined) {
-      bridge.notify('no session yet - submit a message to start', 'warning')
+      bridge.notify(t('notice.noSessionYet'), 'warning')
       return
     }
     try {
@@ -2063,13 +2102,13 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
         label: id.slice(-12),
       })
     } catch (error: unknown) {
-      bridge.notify(`fork failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+      bridge.notify(t('notice.forkFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
     }
   }
 
   const switchSession = (row: SessionRow): void => {
     if (!row.resumable) {
-      bridge.notify('subagent conversations are read-only', 'warning')
+      bridge.notify(t('notice.subagentsReadOnly'), 'warning')
       return
     }
     requestSwitch({ target: { sessionId: row.id, resume: true }, label: row.title ?? row.id.slice(-12) })
@@ -2234,29 +2273,29 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   // the agent always receives the startup prompt first.
   if (startup.prompt !== undefined || (startup.images?.length ?? 0) > 0) {
     if ((startup.images?.length ?? 0) > 0) {
-      bridge.notify(`processing ${startup.images!.length} startup image${startup.images!.length === 1 ? '' : 's'}…`)
+      bridge.notify(t('notice.startupImages', { count: startup.images!.length, plural: startup.images!.length === 1 ? '' : 's' }))
     }
     void inputGate.run(async deliver => {
       const images = await saveImagePaths(startup.images ?? [], ctx.get('attachments'))
-      if (images.length > 0) bridge.notify(`${images.length} startup image${images.length === 1 ? '' : 's'} attached`)
+      if (images.length > 0) bridge.notify(t('notice.startupImagesAttached', { count: images.length, plural: images.length === 1 ? '' : 's' }))
       deliver({ text: startup.prompt ?? '', mode: 'followup', images })
     }).catch((error: unknown) => {
-      bridge.notify(`initial prompt failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+      bridge.notify(t('notice.initialPromptFailed', { message: error instanceof Error ? error.message : String(error) }), 'error')
     })
   }
 
   async function copyLastResponse(): Promise<string> {
     const text = latestAssistantText(store.getView())
-    if (text === undefined) return 'nothing to copy yet'
+    if (text === undefined) return t('notice.copyEmpty')
     await copyText(text)
-    return 'copied latest response'
+    return t('notice.copied')
   }
 
   // A corrupt statusline config must not vanish silently: surface it once
   // the notice channel is live, after the first frame settles.
   if (statuslineWarning !== undefined) {
     setTimeout(() => {
-      bridge.notify('statusline config unreadable, using defaults: ' + statuslineWarning, 'warning')
+      bridge.notify(t('notice.statuslineConfigUnreadable', { message: statuslineWarning }), 'warning')
     }, 50)
   }
   // Same one-shot surface for a corrupt theme file (dark fallback stays live).
@@ -2267,13 +2306,13 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   }
   if (themeWarning !== undefined) {
     setTimeout(() => {
-      bridge.notify('theme config unreadable, using dark: ' + themeWarning, 'warning')
+      bridge.notify(t('notice.themeConfigUnreadable', { message: themeWarning }), 'warning')
     }, 50)
   }
   // And for a corrupt animations file (on-by-default fallback stays live).
   if (animationsWarning !== undefined) {
     setTimeout(() => {
-      bridge.notify('animations config unreadable, animations stay on: ' + animationsWarning, 'warning')
+      bridge.notify(t('notice.animationsConfigUnreadable', { message: animationsWarning }), 'warning')
     }, 50)
   }
 

package/src/input-split.ts

@@ -62,10 +62,30 @@ export function createKeypressSplitter(): KeypressSplitter {
         }
         const head = buffer[0]
         if (head !== '\x1b') {
-          // Plain bytes key one at a time; a surrogate pair is one grapheme
-          // and must not split into two lone surrogates.
-          const pair = head >= '\uD800' && head <= '\uDBFF' && buffer[1] !== undefined
-          const take = pair ? 2 : 1
+          // C0 / DEL stay one key so a coalesced ` \r` is still space then
+          // Enter. A printable run (file drag or unbracketed path paste on
+          // any platform, including CJK) must stay ONE unit: splitting a
+          // long path into tens of setStates overflows React's update depth
+          // and never reaches the attachment parser. Typed keys still
+          // arrive as one-byte chunks, so this only batches what the OS
+          // already coalesced.
+          if (head < ' ' || head === '\x7f') {
+            units.push(head)
+            buffer = buffer.slice(1)
+            continue
+          }
+          let take = 0
+          while (take < buffer.length) {
+            const ch = buffer[take]
+            if (ch === '\x1b' || ch < ' ' || ch === '\x7f') break
+            if (ch >= '\uD800' && ch <= '\uDBFF') {
+              if (buffer[take + 1] === undefined) break
+              take += 2
+              continue
+            }
+            take += 1
+          }
+          if (take === 0) break
           units.push(buffer.slice(0, take))
           buffer = buffer.slice(take)
           continue