herm-tui 1.0.0-dev.1

package/src/app/turnReducer.ts

@@ -0,0 +1,390 @@
+// Chat turn state — messages, streaming flags. Parts are appended in the
+// order the gateway emits them (text → tool → text → …), so rendering can
+// iterate `parts` chronologically without regrouping.
+
+import type { Message, Part, TextPart, ToolPart, PromptPart, PromptReq, Usage } from "../types/message"
+import { mid, pid } from "../types/message"
+import type { SubagentPayload, TranscriptMessage } from "../utils/gateway-types"
+
+export type TurnState = {
+  messages: Message[]
+  streaming: boolean
+  hasContent: boolean
+  toolActive: boolean
+}
+
+export const initialTurn: TurnState = {
+  messages: [],
+  streaming: false,
+  hasContent: false,
+  toolActive: false,
+}
+
+export type Action =
+  | { kind: "reset" }
+  | { kind: "load"; messages: Message[] }
+  | { kind: "push"; message: Message }
+  | { kind: "user"; text: string }
+  | { kind: "system"; text: string }
+  | { kind: "message.start" }
+  | { kind: "message.delta"; chunk: string }
+  | { kind: "message.complete"; text?: string; usage?: Usage }
+  | { kind: "tool.start"; id: string; name: string; preview?: string }
+  | { kind: "tool.progress"; name?: string; preview?: string }
+  | { kind: "tool.generating"; name?: string }
+  | { kind: "tool.complete"; id: string; summary?: string; error?: string; inline_diff?: string }
+  | { kind: "thinking"; text: string; final: boolean }
+  | { kind: "subagent"; event: "start" | "thinking" | "tool" | "progress" | "complete"; payload: SubagentPayload }
+  | { kind: "prompt"; id: string; req: PromptReq }
+  | { kind: "prompt.answered"; id: string; label: string; ok: boolean }
+  | { kind: "error"; text: string }
+  | { kind: "interrupt.notice"; text: string }
+
+export function turnReducer(state: TurnState, a: Action): TurnState {
+  switch (a.kind) {
+    case "reset":
+      return initialTurn
+
+    case "load":
+      return { ...initialTurn, messages: a.messages }
+
+    case "push":
+      return { ...state, messages: [...state.messages, a.message] }
+
+    case "user":
+      return { ...state, messages: [...state.messages, userMessage(a.text)] }
+
+    case "system":
+      return { ...state, messages: [...state.messages, systemMessage(a.text)] }
+
+    case "message.start":
+      return { ...state, streaming: true, hasContent: false, toolActive: false }
+
+    case "message.delta":
+      return {
+        ...state,
+        hasContent: true,
+        toolActive: false,
+        messages: appendText(state.messages, a.chunk),
+      }
+
+    case "message.complete":
+      return {
+        ...state,
+        streaming: false,
+        hasContent: false,
+        toolActive: false,
+        messages: finalize(state.messages, a.text, a.usage),
+      }
+
+    case "tool.start": {
+      // `context` carries the raw tool input; when JSON-shaped we keep it
+      // as args so the UI can render KV lines on expand.
+      const json = a.preview && /^\s*\{/.test(a.preview)
+      const part: ToolPart = {
+        type: "tool", id: a.id, name: a.name,
+        args: json ? a.preview! : "",
+        status: "running", startedAt: Date.now(),
+        preview: a.preview,
+      }
+      return {
+        ...state,
+        toolActive: true,
+        hasContent: false,
+        messages: appendPart(state.messages, part, true),
+      }
+    }
+
+    case "tool.progress":
+      return {
+        ...state,
+        messages: updateRunningTool(state.messages, a.name, p => ({
+          ...p, preview: a.preview || p.preview,
+        })),
+      }
+
+    case "tool.generating":
+      return {
+        ...state,
+        messages: updateRunningTool(state.messages, a.name, p => ({
+          ...p, preview: p.preview ?? "generating…",
+        })),
+      }
+
+    case "tool.complete":
+      return {
+        ...state,
+        toolActive: false,
+        messages: updateToolById(state.messages, a.id, p => ({
+          ...p,
+          status: (a.error ? "error" : "done") as ToolPart["status"],
+          duration: p.startedAt ? Date.now() - p.startedAt : undefined,
+          preview: a.summary || a.inline_diff || p.preview,
+          result: a.error || a.summary,
+          diff: a.inline_diff,
+        })),
+      }
+
+    case "thinking":
+      return { ...state, messages: upsertThinking(state.messages, a.text, a.final) }
+
+    case "subagent":
+      return { ...state, messages: renderSubagent(state.messages, a.event, a.payload) }
+
+    case "prompt": {
+      const part: PromptPart = {
+        type: "prompt", id: a.id, variant: a.req.variant, req: a.req,
+      }
+      // Append to the in-progress assistant turn (prompts arrive
+      // mid-stream, between tool calls). Seal any open text so the
+      // prompt sits chronologically.
+      return {
+        ...state,
+        messages: appendPart(state.messages, part, true),
+      }
+    }
+
+    case "prompt.answered":
+      return {
+        ...state,
+        messages: updatePrompt(state.messages, a.id, p => ({
+          ...p, answered: { label: a.label, ok: a.ok, at: Date.now() },
+        })),
+      }
+
+    case "error":
+      return {
+        ...state,
+        streaming: false,
+        hasContent: false,
+        toolActive: false,
+        messages: [...state.messages, systemMessage(`Error: ${a.text}`)],
+      }
+
+    case "interrupt.notice": {
+      const last = state.messages[state.messages.length - 1]
+      const already = last?.role === "system"
+        && last.parts[0]?.type === "text"
+        && last.parts[0].content.includes(a.text)
+      if (already) return state
+      return { ...state, messages: [...state.messages, systemMessage(a.text)] }
+    }
+  }
+}
+
+// ── Constructors ────────────────────────────────────────────────────
+
+function userMessage(text: string): Message {
+  return {
+    id: mid(), role: "user",
+    parts: [{ type: "text", content: text, streaming: false }],
+    timestamp: Date.now() / 1000,
+  }
+}
+
+function systemMessage(text: string): Message {
+  return {
+    id: mid(), role: "system",
+    parts: [{ type: "text", content: text, streaming: false }],
+    timestamp: Date.now() / 1000,
+  }
+}
+
+// Flatten a transcript row's `text` to a plain string for the reducer.
+// Native-mode image routing stores user turns as an OpenAI content-parts
+// list (`[{type:"text",text:…}, {type:"image_url",image_url:{url:…}}, …]`)
+// instead of a plain string. ChafaImage needs a path, so a `data:` URL
+// can't be reconstructed into a MEDIA: line — but we emit the `withMedia`
+// prefix on the wire now (app.tsx:send), so the path sits inside the
+// leading {type:"text"} fragment and survives.
+function flatten(text: TranscriptMessage["text"]): string {
+  if (typeof text === "string") return text
+  if (!Array.isArray(text)) return ""
+  const out: string[] = []
+  for (const p of text) {
+    if (p && typeof p === "object" && "type" in p && p.type === "text"
+        && "text" in p && typeof p.text === "string") out.push(p.text)
+  }
+  return out.join("\n")
+}
+
+export function transcriptToMessages(rows: TranscriptMessage[]): Message[] {
+  return rows
+    .filter(r => r.role === "user" || r.role === "assistant")
+    .map(r => ({ role: r.role, content: flatten(r.text) }))
+    .filter(r => r.content)
+    .map(r => ({
+      id: mid(),
+      role: r.role as "user" | "assistant",
+      parts: [{ type: "text" as const, content: r.content, streaming: false }],
+      timestamp: Date.now() / 1000,
+    }))
+}
+
+// ── Internals ───────────────────────────────────────────────────────
+
+function assistant(parts: Part[]): Message {
+  return { id: mid(), role: "assistant", parts, timestamp: Date.now() / 1000 }
+}
+
+function withLastAssistant(
+  messages: Message[],
+  fn: (m: Message) => Message,
+  otherwise: () => Message,
+): Message[] {
+  const last = messages[messages.length - 1]
+  if (last?.role === "assistant") return [...messages.slice(0, -1), fn(last)]
+  return [...messages, otherwise()]
+}
+
+/** Seal the trailing streaming text part so the next chunk starts fresh. */
+function seal(parts: Part[]): Part[] {
+  const last = parts[parts.length - 1]
+  if (last?.type === "text" && last.streaming)
+    return [...parts.slice(0, -1), { ...last, streaming: false }]
+  return parts
+}
+
+/** Append a chunk to the trailing streaming text part, or open a new one. */
+function appendText(messages: Message[], chunk: string): Message[] {
+  return withLastAssistant(
+    messages,
+    m => {
+      const last = m.parts[m.parts.length - 1]
+      if (last?.type === "text" && last.streaming) {
+        const part: TextPart = { ...last, content: last.content + chunk }
+        return { ...m, parts: [...m.parts.slice(0, -1), part] }
+      }
+      return { ...m, parts: [...m.parts, { type: "text", key: pid(), content: chunk, streaming: true }] }
+    },
+    () => assistant([{ type: "text", key: pid(), content: chunk, streaming: true }]),
+  )
+}
+
+/** Append a non-text part, optionally sealing any open text stream first. */
+function appendPart(messages: Message[], part: Part, close: boolean): Message[] {
+  return withLastAssistant(
+    messages,
+    m => ({ ...m, parts: [...(close ? seal(m.parts) : m.parts), part] }),
+    () => assistant([part]),
+  )
+}
+
+function finalize(messages: Message[], final?: string, usage?: Usage): Message[] {
+  const last = messages[messages.length - 1]
+  if (last?.role === "assistant") {
+    const tail = last.parts[last.parts.length - 1]
+    const parts = tail?.type === "text" && tail.streaming
+      ? [...last.parts.slice(0, -1), { ...tail, content: final || tail.content, streaming: false }]
+      : final && final !== joinText(last.parts)
+        ? [...last.parts, { type: "text" as const, content: final, streaming: false }]
+        : seal(last.parts)
+    return [...messages.slice(0, -1), { ...last, parts, usage }]
+  }
+  if (!final) return messages
+  return [...messages, { ...assistant([{ type: "text", content: final, streaming: false }]), usage }]
+}
+
+function joinText(parts: Part[]): string {
+  return parts.filter(p => p.type === "text").map(p => p.content).join("")
+}
+
+function updateRunningTool(
+  messages: Message[],
+  name: string | undefined,
+  fn: (p: ToolPart) => ToolPart,
+): Message[] {
+  const last = messages[messages.length - 1]
+  if (!last || last.role !== "assistant") return messages
+  for (let i = last.parts.length - 1; i >= 0; i--) {
+    const p = last.parts[i]
+    if (p.type !== "tool" || p.status !== "running") continue
+    if (name && p.name !== name) continue
+    const parts = [...last.parts]
+    parts[i] = fn(p)
+    return [...messages.slice(0, -1), { ...last, parts }]
+  }
+  return messages
+}
+
+function updateToolById(messages: Message[], id: string, fn: (p: ToolPart) => ToolPart): Message[] {
+  const last = messages[messages.length - 1]
+  if (!last || last.role !== "assistant") return messages
+  const parts = last.parts.map(p => p.type === "tool" && p.id === id ? fn(p) : p)
+  return [...messages.slice(0, -1), { ...last, parts }]
+}
+
+/** Prompts can be answered after the assistant turn has moved on
+ *  (user scrolled away, agent kept streaming). Search all messages,
+ *  not just the tail. */
+function updatePrompt(messages: Message[], id: string, fn: (p: PromptPart) => PromptPart): Message[] {
+  return messages.map(m => {
+    if (m.role !== "assistant") return m
+    if (!m.parts.some(p => p.type === "prompt" && p.id === id)) return m
+    return { ...m, parts: m.parts.map(p => p.type === "prompt" && p.id === id ? fn(p) : p) }
+  })
+}
+
+function upsertThinking(messages: Message[], text: string, final: boolean): Message[] {
+  return withLastAssistant(
+    messages,
+    m => {
+      const idx = m.parts.findIndex(p => p.type === "thinking")
+      if (idx >= 0) {
+        const prev = m.parts[idx] as Part & { type: "thinking"; content: string }
+        // `final` (reasoning.available) is a fallback for providers
+        // that don't stream deltas — keep the accumulated buffer if we
+        // have one. Matches Ink turnController.recordReasoningAvailable.
+        const content = final ? prev.content.trim() || text : prev.content + text
+        const parts = [...m.parts]
+        parts[idx] = { ...prev, content, streaming: !final }
+        return { ...m, parts }
+      }
+      return { ...m, parts: [{ type: "thinking" as const, key: pid(), content: text, streaming: !final }, ...m.parts] }
+    },
+    () => assistant([{ type: "thinking", key: pid(), content: text, streaming: !final }]),
+  )
+}
+
+function renderSubagent(
+  messages: Message[],
+  event: "start" | "thinking" | "tool" | "progress" | "complete",
+  p: SubagentPayload,
+): Message[] {
+  // Prefer the stable subagent_id threaded by delegate_tool; fall back
+  // to task_index for older gateways. task_index alone collides when
+  // orchestrator children spawn their own batch (same index, new depth).
+  const id = p.subagent_id ? `sub-${p.subagent_id}` : `sub-${p.task_index}`
+
+  if (event === "start") {
+    const part: ToolPart = {
+      type: "tool", id, name: "delegate_task", args: "",
+      status: "running", startedAt: Date.now(),
+      preview: p.goal, goal: p.goal, depth: p.depth ?? 0, trail: [],
+    }
+    return appendPart(messages, part, true)
+  }
+
+  if (event === "tool" && p.tool_name) {
+    return updateToolById(messages, id, t => ({
+      ...t,
+      trail: [...(t.trail ?? []), { name: p.tool_name!, preview: p.tool_preview }],
+      preview: p.tool_preview ? `${p.tool_name}: ${p.tool_preview}` : p.tool_name,
+    }))
+  }
+
+  if (event === "complete") {
+    const tokens = (p.input_tokens ?? 0) + (p.output_tokens ?? 0)
+    const extra = tokens ? ` · ${(tokens / 1000).toFixed(1)}k tok` : ""
+    return updateToolById(messages, id, t => ({
+      ...t,
+      status: (p.status === "failed" ? "error" : "done") as ToolPart["status"],
+      duration: p.duration_seconds ? p.duration_seconds * 1000 : (t.startedAt ? Date.now() - t.startedAt : undefined),
+      result: p.summary ? p.summary + extra : undefined,
+      preview: t.goal ?? t.preview,
+    }))
+  }
+
+  // thinking / progress — surface transient text on the row.
+  return updateToolById(messages, id, t => ({ ...t, preview: p.text ?? t.preview }))
+}

package/src/app/useAppKeys.ts

@@ -0,0 +1,268 @@
+// Shell-level keyboard routing. Input-scoped keys (popover nav, prompt
+// history) are delegated to the Composer via its imperative handle so
+// there is exactly one global useKeyboard.
+
+import { useKeyboard, useRenderer } from "@opentui/react"
+import { resolveRenderLib, RGBA, type ParsedKey } from "@opentui/core"
+
+/** Wipe the physical screen and force a full re-emit on next frame. */
+export function redraw(renderer: {
+  rendererPtr: unknown
+  currentRenderBuffer: { clear(c: unknown): void }
+  requestRender(): void
+}) {
+  resolveRenderLib().clearTerminal(renderer.rendererPtr as never)
+  renderer.currentRenderBuffer.clear(RGBA.fromValues(0, 0, 0, 0))
+  renderer.requestRender()
+}
+import { useRef, useEffect, type RefObject } from "react"
+import { copySelection } from "../utils/clipboard"
+import { editInEditor } from "../utils/editor"
+import { useKeys, conflicts } from "../keys"
+import { print as chordPrint } from "../keys/chord"
+import type { ComposerHandle } from "../components/chat/Composer"
+
+const INTERRUPT_MS = 5000
+export const DOUBLE_TAB_MS = 400
+
+type Region = "input" | "content"
+
+type Opts = {
+  tab: number
+  tabMax: number
+  chatTab: number
+  setTab: (fn: (t: number) => number) => void
+  focusRegion: Region
+  setFocusRegion: (r: Region | ((r: Region) => Region)) => void
+  streaming: boolean
+  dialogOpen: boolean
+  composer: RefObject<ComposerHandle | null>
+  /** Offer the key to a pending inline prompt card. Return true to
+   *  consume + stopPropagation; false to fall through to the shell. */
+  onPromptKey?: (key: ParsedKey) => boolean
+  /** Idle-mode Esc, before focus bounce. Return true to consume. */
+  onEscape?: () => boolean
+  onInterrupt: () => void
+  onInterruptNotice: () => void
+  onCopyLast: () => void
+  onAttachClipboard: () => void
+  /** Remove the last pending attachment (backspace on empty composer). */
+  onDetachLast: () => boolean
+  onNotice: (text: string) => void
+  onToggleSidebar: () => void
+}
+
+export function useAppKeys(o: Opts) {
+  const renderer = useRenderer()
+  const keys = useKeys()
+  const lastEsc = useRef(0)
+  const lastTab = useRef(0)
+
+  // Tabs with their own keyboard surface own focus on entry; Chat keeps
+  // the composer since its content region has no keybinds.
+  const regionFor = (t: number): Region => t === o.chatTab ? "input" : "content"
+
+  // One-shot conflict scan whenever the resolved table changes (i.e. a
+  // user override was written). DEFAULTS are swept by a test, so any
+  // hit here is user-introduced — warn but honor the override.
+  useEffect(() => {
+    const found = conflicts(keys.table)
+      // Same chord, disjoint modes — dialogOpen gate below makes these
+      // mutually exclusive, not a real collision.
+      .filter(c => !(c.a === "session.interrupt" && c.b === "dialog.cancel"))
+    if (found.length === 0) return
+    const first = found[0]
+    o.onNotice(
+      `Keybinding conflict: ${chordPrint([first.chord])} → ${first.a} and ${first.b}` +
+      (found.length > 1 ? ` (+${found.length - 1} more)` : ""),
+    )
+  }, [keys.table])
+
+  useKeyboard((key) => {
+    const c = o.composer.current
+
+    if (keys.match("app.exit", key)) {
+      if (copySelection(renderer)) return
+      // destroy() tears down the renderer but does NOT exit the process
+      // — under `bun --watch` (or with CONTROL/PERF servers up) the
+      // event loop stays alive and the user is stranded on the main
+      // screen with no prompt. exit(0) fires the `exit` hook in
+      // terminal-reset which flushes the mode-reset blob synchronously.
+      renderer.destroy()
+      process.exit(0)
+    }
+
+    if (keys.match("app.suspend", key)) {
+      renderer.suspend()
+      process.kill(process.pid, "SIGTSTP")
+      // Resumes on SIGCONT; OpenTUI's suspend/resume cycle re-enables
+      // raw mode and redraws on the next frame.
+      process.once("SIGCONT", () => renderer.resume())
+      return
+    }
+
+    if (keys.match("app.redraw", key)) {
+      // OpenTUI's renderNative() only emits cells that diff against
+      // the previous frame, so pty garbage from a child process / ssh
+      // banner / macOS Cmd+K sticks until those cells happen to
+      // change. clearTerminal() writes CSI 2J + CSI H to wipe the
+      // physical screen; zeroing currentRenderBuffer (the diff
+      // baseline — same trick resume() uses) makes the next normal
+      // render see every populated cell as changed and re-emit it.
+      // Calling lib.render(ptr, true) directly would bypass the loop
+      // and rot the native buffer-swap state, so go through
+      // requestRender() instead.
+      redraw(renderer)
+      key.stopPropagation()
+      return
+    }
+
+    if (keys.match("app.sidebar", key)) {
+      o.onToggleSidebar()
+      return
+    }
+
+    // Modal means modal: with a dialog open, the shell yields
+    // everything except process-level escapes above. DialogProvider
+    // handles Esc-to-close; tabs/composer/interrupt all sit behind the
+    // overlay and shouldn't move.
+    if (o.dialogOpen) return
+
+    // Inline prompt gets first refusal on nav/answer keys. It only
+    // claims the narrow set it cares about (←/→/↑/↓/Enter/Esc/1-9);
+    // everything else — including printable chars while the composer
+    // is focused — falls through so typing-to-queue still works.
+    if (o.onPromptKey && !keys.leader && !key.ctrl && !key.meta && key.eventType !== "release") {
+      if (o.onPromptKey(key)) { key.stopPropagation(); return }
+    }
+
+    if (keys.match("editor.open", key) && !o.streaming) {
+      const seed = c?.value() ?? ""
+      void editInEditor(renderer, seed).then(out => {
+        if (out === undefined) {
+          if (!process.env.VISUAL && !process.env.EDITOR)
+            o.onNotice("Set $EDITOR or $VISUAL to use the external editor")
+          return
+        }
+        c?.set(out)
+        o.setFocusRegion("input")
+      })
+      return
+    }
+
+    if (keys.match("tab.prev", key)) {
+      o.setTab(t => { const n = Math.max(0, t - 1); o.setFocusRegion(regionFor(n)); return n })
+      return
+    }
+    if (keys.match("tab.next", key)) {
+      o.setTab(t => { const n = Math.min(o.tabMax, t + 1); o.setFocusRegion(regionFor(n)); return n })
+      return
+    }
+    // <leader> 1..0 → tab 1..10 (1-indexed), <leader> - → tab 11.
+    // Structural, not catalog — ten near-identical rebindable actions is
+    // noise, and the leader itself is the rebindable part.
+    if (keys.leader && !key.ctrl && !key.meta && !key.shift && key.eventType !== "release") {
+      const map: Record<string, number> = {
+        "1": 0, "2": 1, "3": 2, "4": 3, "5": 4,
+        "6": 5, "7": 6, "8": 7, "9": 8, "0": 9, "-": 10,
+      }
+      const n = map[key.name]
+      if (n !== undefined && n <= o.tabMax) {
+        o.setTab(() => { o.setFocusRegion(regionFor(n)); return n })
+        key.stopPropagation()
+        return
+      }
+    }
+
+    // Popover owns up/down/tab/escape while open; stopPropagation keeps the
+    // textarea renderable from also moving the cursor on the same keypress.
+    // Structural — popover nav is composer-state, not a catalog action.
+    if (!o.streaming && c?.popOpen()) {
+      if (key.name === "escape") return c.popCancel()
+      if (key.name === "up") { c.popNav(-1); key.stopPropagation(); return }
+      if (key.name === "down") { c.popNav(1); key.stopPropagation(); return }
+      if (key.name === "tab") return c.popAccept()
+      return
+    }
+
+    if (keys.match("focus.cycle", key) && !o.streaming) {
+      if (o.tab === o.chatTab) {
+        o.setFocusRegion(r => r === "input" ? "content" : "input")
+        return
+      }
+      if (o.focusRegion === "input") {
+        o.setFocusRegion("content")
+        return
+      }
+      // Content-focused on a non-Chat tab: single Tab stays (tab owns it as a
+      // nav key); double-tap within the window jumps to the composer.
+      const now = Date.now()
+      if (now - lastTab.current < DOUBLE_TAB_MS) {
+        o.setFocusRegion("input")
+        lastTab.current = 0
+        key.stopPropagation()
+      } else {
+        lastTab.current = now
+      }
+      return
+    }
+
+    if (keys.match("session.interrupt", key)) {
+      if (!o.streaming && o.onEscape?.()) return
+      if (o.streaming) {
+        const now = Date.now()
+        if (now - lastEsc.current < INTERRUPT_MS) {
+          o.onInterrupt()
+          lastEsc.current = 0
+          return
+        }
+        lastEsc.current = now
+        o.onInterruptNotice()
+        return
+      }
+      if (o.tab === o.chatTab && o.focusRegion === "content") o.setFocusRegion("input")
+      return
+    }
+
+    if (keys.match("reply.copy", key)) return o.onCopyLast()
+    if (keys.match("clipboard.attach", key)) {
+      o.onAttachClipboard()
+      key.stopPropagation()
+      return
+    }
+
+    // ↑/↓ with a single-line buffer cycles prompt history; with a multi-line
+    // buffer historyUp/Down return false so the keystroke falls through to
+    // the textarea renderable's move-up/move-down. No stopPropagation — on a
+    // single-line buffer the textarea's move-up/down is a no-op anyway, and
+    // swallowing the key would starve dialog/select renderables that share
+    // the global key bus while focusRegion is still "input".
+    if (o.focusRegion === "input" && !o.streaming) {
+      if (key.name === "up") return void c?.historyUp()
+      if (key.name === "down") return void c?.historyDown()
+      // Backspace on an empty buffer with attachments → detach the last.
+      // Swallow before the textarea sees it so a subsequent backspace on
+      // a still-empty buffer keeps peeling attachments off, not chars.
+      if (key.name === "backspace" && !key.ctrl && !key.meta
+          && c?.isEmpty() && o.onDetachLast()) {
+        key.stopPropagation()
+        return
+      }
+    }
+
+    // Printable char while Chat transcript has focus → bounce to composer
+    // AND deliver the char (so the first keystroke isn't swallowed). Other
+    // tabs own their printable keys (v=reveal, d=delete, …), so the shell
+    // must not intercept there.
+    if (o.tab === o.chatTab && o.focusRegion === "content" && !o.streaming
+        && !key.ctrl && !key.meta && key.eventType !== "release") {
+      if (key.name.length === 1 && key.name !== " ") {
+        const ch = key.shift && /[a-z]/.test(key.name)
+          ? key.name.toUpperCase() : key.name
+        o.setFocusRegion("input")
+        c?.insert(ch)
+        key.stopPropagation()
+      }
+    }
+  })
+}