herm-tui 1.0.0-dev.1 → 1.0.0-dev.11

package/src/app/turnReducer.ts

@@ -1,390 +0,0 @@
-// 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

@@ -1,268 +0,0 @@
-// 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()
-      }
-    }
-  })
-}