dsh-code 1.0.3 → 1.0.4

package/src/approval.ts

@@ -96,6 +96,13 @@ export function mountApprovalAnswerer(
 
     let resolved = false
     let settle!: (outcome: ApprovalOutcome) => void
+    // Established BEFORE the abort listener mounts: a synchronous throw
+    // between the listener registration and a later construction site would
+    // otherwise leave a subsequent abort invoking an unassigned settle from
+    // inside the AbortSignal listener (an uncaughtException).
+    const settled = new Promise<ApprovalOutcome>((resolve) => {
+      settle = resolve
+    })
     const signal = request.signal
     const onAbort = (): void => withdraw()
     // Detach on every settle so an answered ask never retains a listener on
@@ -136,9 +143,7 @@ export function mountApprovalAnswerer(
     queue.push(slot)
     publish()
 
-    return new Promise<ApprovalOutcome>((resolve) => {
-      settle = resolve
-    }).then((outcome) => {
+    return settled.then((outcome) => {
       if (outcome !== 'cancelled') {
         removeSlot(slot)
         publish()

package/src/authorization-panel.ts

@@ -196,8 +196,7 @@ export function ProviderAuthorizationPanel(props: ProviderAuthorizationPanelProp
     if (input !== '' && !key.ctrl && !key.meta) setDraft(current => current + input)
   })
 
-  if (viewport.maxHeight === 0) return createElement(Box, { display: 'none' })
-  if (viewport.compact) {
+  if (viewport.maxHeight === 0 || viewport.compact) {
     return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('provider login · esc cancel', viewport.contentColumns))
   }
 
@@ -271,8 +270,7 @@ export function ProviderAuthorizationLogoutPanel({ row, confirm, done, back }: {
       setError(reason instanceof Error ? reason.message : String(reason))
     })
   })
-  if (viewport.maxHeight === 0) return createElement(Box, { display: 'none' })
-  if (viewport.compact) return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('y logout · n/esc back', viewport.contentColumns))
+  if (viewport.maxHeight === 0 || viewport.compact) return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('y logout · n/esc back', viewport.contentColumns))
   return createElement(
     Box,
     { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().warn) },

package/src/commands.ts

@@ -38,16 +38,22 @@ export function watchCommands(ctx: Context): CommandsView {
   let agent: Agent | undefined
   let descriptors: readonly CommandDescriptor[] = []
   let error: string | undefined
+  // The agent whose scoped view the current descriptors were read for: a
+  // failure before this agent ever loaded clears the list instead of keeping
+  // another session's commands completable here.
+  let loadedFor: Agent | undefined
   const listeners = new Set<() => void>()
   const refresh = (): void => {
     if (commands === undefined || agent === undefined) return
     try {
       descriptors = commands.list(agent)
+      loadedFor = agent
       error = undefined
     } catch (cause: unknown) {
-      // Keep the last good catalog, but change its identity so subscribers
-      // can render the recoverable failure in /help.
-      descriptors = [...descriptors]
+      // Keep the last good catalog for the SAME agent, but change its identity
+      // so subscribers can render the recoverable failure in /help; an agent
+      // that never loaded starts from empty.
+      descriptors = loadedFor === agent ? [...descriptors] : []
       error = cause instanceof Error ? cause.message : String(cause)
     }
     for (const listener of listeners) listener()
@@ -83,3 +89,21 @@ export function watchCommands(ctx: Context): CommandsView {
 export function isSlashLine(line: string): boolean {
   return /^\/[a-z][a-z0-9_-]*(?=$|[\t ])/u.test(line)
 }
+
+/**
+ * The submission payload for one composer line. Trim is a blank check, not a
+ * rewrite: an ordinary prompt keeps its exact leading indentation, inner
+ * layout, and trailing spaces (pasted code must reach the model verbatim).
+ * Only trailing line terminators are stripped — a draft's final newline is a
+ * paste/Enter artifact (an open bracketed paste turns Enter into an inserted
+ * newline), never deliberate content. A syntactic slash line still normalizes
+ * fully so command routing stays stable (completion inserts a trailing space
+ * after `/name`).
+ * @param line - the complete draft text.
+ * @returns the text to submit verbatim.
+ */
+export function submissionPayload(line: string): string {
+  const withoutTrailingNewlines = line.replace(/[\r\n]+$/u, '')
+  const trimmed = withoutTrailingNewlines.trim()
+  return isSlashLine(trimmed) ? trimmed : withoutTrailingNewlines
+}

package/src/index.ts

@@ -33,11 +33,12 @@ import type {} from '@deepseek-ai/cordis-plugin-loader'
 import type {} from '@deepseek-ai/dsh-cmdline'
 import { App, type NoticeTone } from './app.ts'
 import { mountApprovalAnswerer, type ApprovalStore } from './approval.ts'
-import { isSlashLine, watchCommands, type CommandsView } from './commands.ts'
+import { isSlashLine, submissionPayload, watchCommands, type CommandsView } from './commands.ts'
 import { internals, type TuiMount } from './internals.ts'
 import { syncModelCapabilities } from './model-capabilities.ts'
 import { buildModelSelection, applyModelSelectionToConfig, loadModelDirectory, modelSelectionLabel, resolveEffectiveSelection, type ModelRow } from './models.ts'
 import {
+  discoverProviderModels,
   loadProviderSettings,
   removeProviderSettings,
   saveProviderCredential,
@@ -243,6 +244,48 @@ export async function runQuitSequence(
   return started
 }
 
+/** One composer submission waiting behind the startup delivery. */
+export interface QueuedSubmission {
+  readonly text: string
+  readonly mode: 'followup' | 'steer'
+  readonly images: readonly ImageBlock[]
+}
+
+/**
+ * Order-preserving gate for composer input while the startup prompt/images
+ * are still preparing. Anything submitted before the startup delivery settles
+ * queues and flushes afterwards in submit order, so the initial request can
+ * never be overtaken by typing that raced a slow image preparation. The flush
+ * also runs when the startup delivery fails: user input is never stranded.
+ */
+export class StartupInputGate {
+  private readonly queued: QueuedSubmission[] = []
+  private pending = false
+  constructor(private readonly deliver: (submission: QueuedSubmission) => void) {}
+
+  /** Submit one line: delivered now while idle, queued behind the startup delivery otherwise. */
+  submit(submission: QueuedSubmission): void {
+    if (this.pending) this.queued.push(submission)
+    else this.deliver(submission)
+  }
+
+  /**
+   * Run the startup delivery — the callback receives the direct-delivery sink
+   * for the startup prompt itself — then flush everything that queued behind
+   * it, in order, even when the callback rejects.
+   */
+  async run(startup: (deliver: (submission: QueuedSubmission) => void) => Promise<void>): Promise<void> {
+    this.pending = true
+    try {
+      await startup(submission => this.deliver(submission))
+    } finally {
+      this.pending = false
+      const queued = this.queued.splice(0)
+      for (const submission of queued) this.deliver(submission)
+    }
+  }
+}
+
 /**
  * Resolve the invocation's target session against the persisted headers.
  * @param startup - the parsed startup flags.
@@ -505,7 +548,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   const commands: CommandsView = watchCommands(ctx)
   if (agent !== undefined) commands.setAgent(agent)
 
-  const skills: SkillsView = watchSkills(ctx)
+  const skills: SkillsView = watchSkills(ctx, cwd)
   if (agent !== undefined) skills.setAgent(agent)
 
   // Approval answerer: renders the ask as a y/n bar; only this TUI's agent is
@@ -530,9 +573,17 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     const subject = payload.agent
     const header = subject.session.header
     if (header.parentSession === undefined && header.origin !== 'subagent') return next()
+    // Only the ACTIVE session's explicit pick may steer a subagent request.
+    // During a switch window the old agent can still be mid-flight; routing
+    // it by the NEW session's pick sent one of its requests to the wrong
+    // model. A subject outside the active tree falls back to its own request
+    // header (plus any explicit /subagent override, which is user intent).
+    const activeAgent = active
+    const belongsToActive = activeAgent !== undefined
+      && (header.parentSession ?? subject.session.id) === activeAgent.session.id
     const picked = subagentOverride
       ?? resolveEffectiveSelection(
-        active?.selection.picked ?? pendingSelection,
+        belongsToActive && activeAgent !== undefined ? (activeAgent.selection.picked ?? pendingSelection) : undefined,
         subject.session.requestHeader()?.config,
         currentDefaults(),
       )
@@ -695,12 +746,18 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     off()
     for (const dispose of offCapabilitySync) dispose()
     if (capabilitySyncTimer !== undefined) clearTimeout(capabilitySyncTimer)
-    mountRef.current?.unmount()
     const currentSession = session
     const currentActive = active
     const report = (name: string, error: unknown): void => {
       internals.stderr.write(`dsh: quit ${name} failed: ${error instanceof Error ? error.message : String(error)}\n`)
     }
+    // A throwing unmount must not strand the terminal (stdin tap alive,
+    // keyboard protocol stacks unpopped) or skip the exit sequence below.
+    try {
+      mountRef.current?.unmount()
+    } catch (error: unknown) {
+      report('unmount', error)
+    }
     // One ordered cleanup: settle the visible session (if any — a bare launch
     // that never composed one resolves immediately), then wait for the final
     // in-flight composition (its work swallows errors and the quitting guard
@@ -770,6 +827,9 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     })
   }
 
+  /** Delivery serialization state: the chain's epoch pins it to one session. */
+  let deliveryChain: { epoch: number; tail: Promise<void> } = { epoch: 0, tail: Promise.resolve() }
+
   /** Deliver one trimmed line to the live session, expanding mentions first. */
   const deliverLine = (line: string, mode: 'followup' | 'steer', images: readonly ImageBlock[] = []): void => {
     const currentAgent = agent!
@@ -788,6 +848,15 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       bridge.notify(`invalid session reference: ${error instanceof Error ? error.message : String(error)}`, 'error')
       return
     }
+    // Ordered delivery: the inbox order IS the user's message order. A line
+    // with session mentions prepares asynchronously, and a later plain line
+    // used to deliver synchronously past it. Every line now waits for the
+    // previous line of the same session; an epoch change (switch/quit)
+    // abandons the chain instead of gating the next session on the old one.
+    if (deliveryChain.epoch !== epoch) deliveryChain = { epoch, tail: Promise.resolve() }
+    const enqueueDelivery = (run: () => void): void => {
+      deliveryChain.tail = deliveryChain.tail.then(run)
+    }
     const atEpoch = epoch
     const deliver = (readable: string, context?: UserMessage): void => {
       // A switch/quit landed while the snapshot was being prepared: never
@@ -818,19 +887,19 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       }
     }
     if (parsed.references.length === 0) {
-      deliver(parsed.text)
+      enqueueDelivery(() => deliver(parsed.text))
       return
     }
     const controller = new AbortController()
     pendingControllers.add(controller)
-    void currentMentions.prepare(parsed, controller.signal).then((prepared) => {
+    enqueueDelivery(() => currentMentions.prepare(parsed, controller.signal).then((prepared) => {
       pendingControllers.delete(controller)
       deliver(prepared.text, prepared.additionalContext)
     }, (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')
-    })
+    }))
   }
 
   // Deferred first-session creation for a bare launch: the session is composed
@@ -868,22 +937,45 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
           void next.handle.dispose().catch(() => {})
           return
         }
-        active = next
-        agent = next.agent
-        session = next.session
-        store = next.store
-        mentions = next.mentions
-        subagents.reset()
-        pendingMode = undefined
-        pendingPermission = undefined
-        commands.setAgent(agent)
-        skills.setAgent(agent)
-        // The App mounts with a placeholder key until the first input; the
-        // key-change remount below must start from a clean screen or the ghost
-        // static header stays visible above the new one (same source-backed
-        // clear the session-switch path performs).
-        process.stdout.write('\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[3J\x1b[H')
-        renderCurrent()
+        const previous = { active, agent, session, store, mentions }
+        try {
+          active = next
+          agent = next.agent
+          session = next.session
+          store = next.store
+          mentions = next.mentions
+          subagents.reset()
+          pendingMode = undefined
+          pendingPermission = undefined
+          commands.setAgent(agent)
+          skills.setAgent(agent)
+          // The App mounts with a placeholder key until the first input; the
+          // key-change remount below must start from a clean screen or the ghost
+          // static header stays visible above the new one (same source-backed
+          // clear the session-switch path performs).
+          process.stdout.write('\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[3J\x1b[H')
+          renderCurrent()
+        } catch (error: unknown) {
+          // The session composed but the screen handoff threw (stdout EPIPE,
+          // a render-time failure). Roll the published state back exactly
+          // like the switch path does — otherwise the runner reports "session
+          // creation failed" while the new session is actually live, clears
+          // the queued inputs, and every later line lands in the ghost. The
+          // queued inputs are KEPT for the next attempt.
+          active = previous.active
+          agent = previous.agent
+          session = previous.session
+          store = previous.store === undefined ? createTranscriptStore() : previous.store
+          mentions = previous.mentions === undefined ? createMentions(ctx, undefined, cwd) : previous.mentions
+          if (agent !== undefined) {
+            commands.setAgent(agent)
+            skills.setAgent(agent)
+          }
+          await next.handle.dispose().catch(() => {})
+          if (!quitting) renderCurrent()
+          bridge.notify(`session activation failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+          return
+        }
         abortPendingControllers()
         epoch += 1
         const queued = pendingInputs.splice(0)
@@ -898,9 +990,11 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   }
 
   /** Deliver one readable line to the agent, expanding session mentions first. */
-  const send = (text: string, mode: 'followup' | 'steer', images: readonly ImageBlock[] = []): void => {
-    const line = text.trim()
-    if (line === '' && images.length === 0) return
+  const sendNow = (text: string, mode: 'followup' | 'steer', images: readonly ImageBlock[] = []): void => {
+    // Blank check on the trimmed form; the payload itself keeps the draft's
+    // exact whitespace unless the line is a syntactic slash command.
+    const line = submissionPayload(text)
+    if (line.trim() === '' && images.length === 0) return
     if (images.length === 0 && line.startsWith('/mode ')) {
       void switchModeAction(line.slice(6).trim()).then(
         selected => bridge.notify(`mode → ${selected}`),
@@ -925,6 +1019,13 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     deliverLine(line, mode, images)
   }
 
+  // Startup serialization: input submitted while the startup prompt/images
+  // are still preparing queues behind the initial request.
+  const inputGate = new StartupInputGate(({ text, mode, images }) => sendNow(text, mode, images))
+  const send = (text: string, mode: 'followup' | 'steer', images: readonly ImageBlock[] = []): void => {
+    inputGate.submit({ text, mode, images })
+  }
+
   /** Dispatch one submitted line: slash commands to the registry, other text to the agent. */
   const dispatch = (text: string, images: readonly ImageBlock[] = []): void => {
     send(text, 'followup', images)
@@ -1261,14 +1362,19 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       session = next.session
       store = next.store
       mentions = next.mentions
-      subagents.reset()
-      pendingMode = undefined
-      pendingPermission = undefined
       commands.setAgent(agent)
       skills.setAgent(agent)
       try {
         process.stdout.write('\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[3J\x1b[H')
         renderCurrent()
+        // Only a successful handoff may clear the transient per-session
+        // surfaces: a rolled-back switch keeps the previous session's
+        // subagent feed plus the user's pre-session /mode and permission
+        // picks (the bare-launch promise: explicit choices survive until
+        // composition takes them).
+        subagents.reset()
+        pendingMode = undefined
+        pendingPermission = undefined
       } catch (error: unknown) {
         active = previous
         agent = previous?.agent
@@ -1288,7 +1394,13 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       // No previous session (a bare launch switched straight into a resume):
       // nothing to flush or dispose, so just confirm the activation.
       if (previous === undefined) {
-        bridge.notify(`${next.resumed ? 'resumed' : 'created'} ${next.session.id.slice(-12)} · mode ${next.mode}`)
+        // The key-change remount above swaps the App in this same synchronous
+        // continuation; the new App registers its bridge.notify in a passive
+        // 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}`)
+        }, 0)
         return
       }
       let cleanupWarning: string | undefined
@@ -1494,6 +1606,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       subscribeModelProviders: listener => subscribeProviderSettings(ctx, listener),
       saveModelProviderCredential: (target, key) => saveProviderCredential(ctx, target, key),
       saveModelProviderConfiguration: (target, configuration) => saveProviderConfiguration(ctx, target, configuration),
+      discoverModelProvider: (target, request, signal) => discoverProviderModels(ctx, target, request, signal),
       unsetModelProviderCredential: target => unsetProviderCredential(ctx, target),
       removeModelProvider: target => removeProviderSettings(ctx, target),
       loadProviderAuthorizations: () => loadProviderAuthorizations(ctx),
@@ -1557,18 +1670,20 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   mountRef.current = io.mount(appElement())
 
   // Startup prompt/images use the same durable delivery path as composer
-  // submissions. Image bytes are committed before the user/message event.
+  // submissions. Image bytes are committed before the user/message event, and
+  // input typed during that preparation queues behind the initial request so
+  // 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'}…`)
     }
-    void saveImagePaths(startup.images ?? [], ctx.get('attachments')).then(
-      images => {
-        if (images.length > 0) bridge.notify(`${images.length} startup image${images.length === 1 ? '' : 's'} attached`)
-        send(startup.prompt ?? '', 'followup', images)
-      },
-      (error: unknown) => bridge.notify(`initial prompt failed: ${error instanceof Error ? error.message : String(error)}`, 'error'),
-    )
+    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`)
+      deliver({ text: startup.prompt ?? '', mode: 'followup', images })
+    }).catch((error: unknown) => {
+      bridge.notify(`initial prompt failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+    })
   }
 
   async function copyLastResponse(): Promise<string> {

package/src/input-split.ts

@@ -0,0 +1,191 @@
+/**
+ * Terminal input arrives as byte chunks, and one chunk can carry several
+ * keypresses: a fast space-then-enter, a bridged stdin that batches reads, a
+ * middle-click paste. Ink parses each chunk as exactly one keypress —
+ * `parseKeypress(' \r')` matches neither member, so both keys silently
+ * vanish (a multi-select question answered with an empty set). The splitter
+ * below cuts every chunk into the individual keypress units Ink's parser
+ * expects, keeping escape sequences and bracketed-paste blocks intact, and
+ * the stdin proxy feeds the split stream to the Ink mount.
+ *
+ * @module @deepseek-ai/dsh-tui/input-split
+ */
+
+import { PassThrough } from 'node:stream'
+import { PASTE_BRACKET_TIMEOUT_MS } from './keyboard.ts'
+
+/** Bracketed-paste wrapper bytes; the whole block travels as one unit. */
+const PASTE_START = '\x1b[200~'
+const PASTE_END = '\x1b[201~'
+
+/** One keypress cut from the input stream. */
+export interface KeypressSplitter {
+  /** Feed one chunk; returns every keypress unit this chunk completed. */
+  push(chunk: string): string[]
+  /** Whether an unterminated bracketed-paste block is currently held. */
+  openPaste(): boolean
+  /**
+   * Last-resort escape hatch for a paste whose end marker never arrived:
+   * drop the start marker and emit the held bytes as plain keypress units so
+   * nothing (Esc and Ctrl+C included) stays hostage. Inert when no paste is
+   * open.
+   */
+  releaseStalePaste(): string[]
+}
+
+/** Final byte of a CSI sequence (\x40-\x7e per ECMA-48). */
+const isCsiFinal = (char: string): boolean => char >= '@' && char <= '~'
+
+/**
+ * Build a stateful chunk splitter. A partial unit at the end of one chunk
+ * (a cut CSI sequence, an open paste block) waits in the buffer for the
+ * rest. A chunk-trailing lone ESC emits as the Escape key right away:
+ * terminals send Escape as its own chunk, and holding it hostage for a
+ * sequence that may never continue would break every Esc cancel.
+ */
+export function createKeypressSplitter(): KeypressSplitter {
+  let buffer = ''
+  const push = (chunk: string): string[] => {
+      buffer += chunk
+      const units: string[] = []
+      while (buffer !== '') {
+        // A bracketed paste block is display text, not keypresses: keep the
+        // whole wrapper plus its payload as the single unit the composer
+        // expects, even when the payload contains ESC-looking bytes.
+        if (buffer.startsWith(PASTE_START)) {
+          const end = buffer.indexOf(PASTE_END, PASTE_START.length)
+          if (end < 0) break
+          const stop = end + PASTE_END.length
+          units.push(buffer.slice(0, stop))
+          buffer = buffer.slice(stop)
+          continue
+        }
+        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
+          units.push(buffer.slice(0, take))
+          buffer = buffer.slice(take)
+          continue
+        }
+        // CSI (\x1b[…final) and SS3 (\x1bO<char): hold until complete.
+        if (buffer[1] === '[') {
+          let end = -1
+          for (let at = 2; at < buffer.length; at += 1) {
+            if (isCsiFinal(buffer[at]!)) {
+              end = at
+              break
+            }
+          }
+          if (end < 0) break
+          units.push(buffer.slice(0, end + 1))
+          buffer = buffer.slice(end + 1)
+          continue
+        }
+        if (buffer[1] === 'O') {
+          if (buffer[2] === undefined) break
+          units.push(buffer.slice(0, 3))
+          buffer = buffer.slice(3)
+          continue
+        }
+        if (buffer[1] === undefined) {
+          // Lone ESC: Escape key (see the tradeoff above).
+          units.push(buffer)
+          buffer = ''
+          continue
+        }
+        // Alt+key: ESC glued to one more byte travels as one unit.
+        units.push(buffer.slice(0, 2))
+        buffer = buffer.slice(2)
+      }
+      return units
+    }
+  return {
+    push,
+    openPaste(): boolean {
+      return buffer.startsWith(PASTE_START)
+    },
+    releaseStalePaste(): string[] {
+      if (!buffer.startsWith(PASTE_START)) return []
+      // Strip the unterminated start marker, then re-run the unit loop: the
+      // held bytes flow as ordinary keypresses under all the normal rules.
+      buffer = buffer.slice(PASTE_START.length)
+      return push('')
+    },
+  }
+}
+
+
+/** The stdin-shaped stream the Ink mount renders through. */
+export interface TuiStdin extends PassThrough {
+  /** Mirrors the real stdin so Ink's raw-mode gate passes. */
+  isTTY: boolean
+  /** Forwarded to the real stdin; Ink toggles it around focus. */
+  setRawMode(value: boolean): unknown
+  ref(): void
+  unref(): void
+}
+
+/**
+ * Wrap one real stdin in the splitting proxy: keypress units flow into a
+ * PassThrough Ink reads, while raw-mode/ref calls forward to the source.
+ * @param source - the process (or harness) input stream in raw mode.
+ * @returns the proxy stream plus a dispose that detaches the tap.
+ */
+export function createSplitStdin(source: NodeJS.ReadStream): { stdin: TuiStdin; dispose(): void } {
+  // Object mode matters: a plain stream's read() without a size drains the
+  // whole buffer as one chunk, which would re-coalesce the units this module
+  // exists to separate. In object mode every pushed unit reads back alone.
+  const stream = new PassThrough({ objectMode: true }) as TuiStdin
+  const splitter = createKeypressSplitter()
+  let stalePasteTimer: ReturnType<typeof setTimeout> | undefined
+  const disarmStalePasteTimer = (): void => {
+    if (stalePasteTimer === undefined) return
+    clearTimeout(stalePasteTimer)
+    stalePasteTimer = undefined
+  }
+  // A terminal that drops the end marker must not swallow every following
+  // keypress forever: past the shared paste window the held block is released
+  // as plain text, keeping Esc/Ctrl+C reachable. The App-level paste flag has
+  // its own reset net with the same window, but it can only see markers that
+  // reach Ink — this one guards the bytes that never do.
+  const armStalePasteTimer = (): void => {
+    if (stalePasteTimer !== undefined || !splitter.openPaste()) return
+    stalePasteTimer = setTimeout(() => {
+      stalePasteTimer = undefined
+      for (const unit of splitter.releaseStalePaste()) stream.write(unit)
+      armStalePasteTimer()
+    }, PASTE_BRACKET_TIMEOUT_MS)
+    stalePasteTimer.unref?.()
+  }
+  const onChunk = (chunk: string): void => {
+    for (const unit of splitter.push(String(chunk))) stream.write(unit)
+    if (splitter.openPaste()) armStalePasteTimer()
+    else disarmStalePasteTimer()
+  }
+  const proxy = Object.assign(stream, {
+    isTTY: source.isTTY === true,
+    setRawMode(value: boolean): TuiStdin {
+      source.setRawMode?.(value)
+      return stream
+    },
+    ref(): void {
+      source.ref?.()
+    },
+    unref(): void {
+      source.unref?.()
+    },
+  })
+  source.setEncoding('utf8')
+  source.on('data', onChunk)
+  return {
+    stdin: proxy,
+    dispose(): void {
+      disarmStalePasteTimer()
+      source.removeListener('data', onChunk)
+      source.pause()
+    },
+  }
+}

package/src/internals.ts

@@ -18,6 +18,7 @@ import {
   isVsCodeTerminalEnv,
   shouldEnableKeyboardEnhancement,
 } from './keyboard.ts'
+import { createSplitStdin } from './input-split.ts'
 
 /** A mounted terminal app instance; the runner owns unmount ordering. */
 export interface TuiMount {
@@ -52,19 +53,36 @@ export const internals: {
     // draft, quit). Ink's default `exitOnCtrlC: true` would intercept the
     // normalized control byte first, unmount only its renderer, and leave the
     // Harness runner plus the pushed keyboard protocol alive.
-    const instance = render(element, { exitOnCtrlC: false })
+    // stdin travels through the keypress splitter: Ink parses one chunk as
+    // one keypress, so a coalesced space-then-enter would drop both keys.
+    const tuiStdin = createSplitStdin(process.stdin)
+    // Ink only touches isTTY/setRawMode/ref/read on stdin; the object-mode
+    // proxy satisfies that contract without the full ReadStream surface.
+    const instance = render(element, {
+      exitOnCtrlC: false,
+      stdin: tuiStdin.stdin as unknown as NodeJS.ReadStream,
+      stdout: process.stdout,
+    })
     return {
       rerender(element: ReactElement): void {
         instance.rerender(element)
       },
       unmount(): void {
-        instance.unmount()
-        // Pop only a stack this mount pushed, then disable bracketed paste.
-        process.stdout.write(
-          (keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : '')
-          + BRACKETED_PASTE_DISABLE
-          + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ''),
-        )
+        // The cleanup below must run even when Ink's unmount throws (a
+        // render-teardown failure): a stdin tap or pushed terminal-protocol
+        // stack outliving the app wedges the terminal for whatever runs
+        // next, and a stray exception here must not skip the exit sequence.
+        try {
+          instance.unmount()
+        } finally {
+          tuiStdin.dispose()
+          // Pop only a stack this mount pushed, then disable bracketed paste.
+          process.stdout.write(
+            (keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : '')
+            + BRACKETED_PASTE_DISABLE
+            + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ''),
+          )
+        }
       },
     }
   },