diff --git a/.agents/skills/opentui/SKILL.md b/.agents/skills/opentui/SKILL.md
new file mode 100644
index 0000000..93676ad
--- /dev/null
+++ b/.agents/skills/opentui/SKILL.md
@@ -0,0 +1,69 @@
+---
+name: opentui
+description: Build terminal UIs with OpenTUI. Covers the core API, native audio, keymaps, React and Solid bindings, components, layout, keyboard input, plugins, and testing.
+---
+
+# OpenTUI Skill
+
+Canonical reference docs are authored once in sibling `docs/**/*.mdx` files.
+
+Inside the OpenTUI repo, this skill root lives at `packages/web/src/content/`, so the same files are also visible at `packages/web/src/content/docs/**/*.mdx`.
+
+## Path invariant
+
+- `/docs/<slug>` maps to `docs/<slug>.mdx` relative to this skill root
+- in the repo, that same slug maps to `packages/web/src/content/docs/<slug>.mdx`
+
+## Reading order by area
+
+- Getting started: `/docs/getting-started`
+- Core: `/docs/core-concepts/renderer`
+- Audio: `/docs/core-concepts/audio`
+- Keymap: `/docs/keymap/overview`
+- React: `/docs/bindings/react`
+- Solid: `/docs/bindings/solid`
+- Components: `/docs/components/text`, `/docs/components/input`
+- Layout: `/docs/core-concepts/layout`
+- Keyboard: `/docs/core-concepts/keyboard`
+- Plugins: `/docs/plugins/slots`
+- Reference: `/docs/reference/env-vars`
+
+## Quick routing by intent
+
+| Intent(s)                                                  | Start here                        |
+| ---------------------------------------------------------- | --------------------------------- |
+| `getting-started`, `installation`, `quickstart`, `intro`   | `docs/getting-started.mdx`        |
+| `core`, `renderer`, `terminal`, `scrollback`, `lifecycle`  | `docs/core-concepts/renderer.mdx` |
+| `audio`, `native-audio`, `sound`, `playback`, `pcm`, `fft` | `docs/core-concepts/audio.mdx`    |
+| `keymap`, `keybindings`, `shortcuts`, `commands`, `leader` | `docs/keymap/overview.mdx`        |
+| `layout`, `flexbox`, `yoga`, `positioning`                 | `docs/core-concepts/layout.mdx`   |
+| `keyboard`, `input`, `keybindings`, `paste`, `focus`       | `docs/core-concepts/keyboard.mdx` |
+| `react`, `jsx`, `hooks`, `animation`, `testing`            | `docs/bindings/react.mdx`         |
+| `solid`, `signals`, `jsx`, `hooks`, `animation`, `testing` | `docs/bindings/solid.mdx`         |
+| `plugins`, `plugin`, `slots`, `registry`, `extensions`     | `docs/plugins/slots.mdx`          |
+| `text`, `styling`, `content`, `selection`                  | `docs/components/text.mdx`        |
+| `input`, `form`, `editing`, `focus`                        | `docs/components/input.mdx`       |
+| `env`, `environment`, `configuration`, `flags`             | `docs/reference/env-vars.mdx`     |
+
+For concrete component requests, jump straight to `docs/components/<name>.mdx` after the relevant entry page. For plugin implementation details, narrow from `docs/plugins/slots.mdx` into `docs/plugins/core.mdx`, `docs/plugins/react.mdx`, or `docs/plugins/solid.mdx`.
+
+## Current skill entry pages
+
+- `docs/getting-started.mdx`
+- `docs/core-concepts/renderer.mdx`
+- `docs/core-concepts/audio.mdx`
+- `docs/keymap/overview.mdx`
+- `docs/core-concepts/layout.mdx`
+- `docs/core-concepts/keyboard.mdx`
+- `docs/bindings/react.mdx`
+- `docs/bindings/solid.mdx`
+- `docs/plugins/slots.mdx`
+- `docs/components/text.mdx`
+- `docs/components/input.mdx`
+- `docs/reference/env-vars.mdx`
+
+## Working rules
+
+- Prefer the current entry pages first, then read narrower docs in the same section.
+- Read the sibling `docs/**/*.mdx` files directly instead of copying prose into this file.
+- Use stable `/docs/...` URLs when cross-referencing docs.
diff --git a/.agents/skills/opentui/config.ts b/.agents/skills/opentui/config.ts
new file mode 100644
index 0000000..06059fe
--- /dev/null
+++ b/.agents/skills/opentui/config.ts
@@ -0,0 +1,22 @@
+import { defineCollection, z } from "astro:content"
+
+const docs = defineCollection({
+  type: "content",
+  schema: z.object({
+    title: z.string(),
+    description: z.string().optional(),
+    order: z.number().int().nonnegative().optional(),
+    navTitle: z.string().optional(),
+    skill: z
+      .object({
+        include: z.boolean().default(true),
+        entry: z.boolean().default(false),
+        intents: z.array(z.string().trim().min(1)).default([]),
+      })
+      .optional(),
+  }),
+})
+
+export const collections = {
+  docs,
+}
diff --git a/.agents/skills/opentui/docs/bindings/react.mdx b/.agents/skills/opentui/docs/bindings/react.mdx
new file mode 100644
index 0000000..acfa7a4
--- /dev/null
+++ b/.agents/skills/opentui/docs/bindings/react.mdx
@@ -0,0 +1,464 @@
+---
+title: React
+description: Build terminal UIs with React and OpenTUI
+order: 2
+skill:
+  entry: true
+  intents: [react, jsx, hooks, keyboard, paste, focus, blur, selection, animation, testing]
+---
+
+# React bindings
+
+Build terminal user interfaces using React with familiar patterns and components.
+
+## Installation
+
+Quick start with [bun](https://bun.sh) and [create-tui](https://github.com/msmps/create-tui):
+
+```bash
+bun create tui --template react
+```
+
+Manual installation:
+
+```bash
+bun install @opentui/react @opentui/core react
+```
+
+## Quick start
+
+```tsx
+import { createCliRenderer } from "@opentui/core"
+import { createRoot } from "@opentui/react"
+
+function App() {
+  return <text>Hello, world!</text>
+}
+
+const renderer = await createCliRenderer()
+createRoot(renderer).render(<App />)
+```
+
+## TypeScript configuration
+
+Configure your `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/react",
+    "strict": true,
+    "skipLibCheck": true
+  }
+}
+```
+
+## Runtime-loaded plugin support (if needed)
+
+If your app loads external TS/TSX modules at runtime (for example a file-based plugin system), import this once in your app entry before dynamic imports:
+
+```ts
+import "@opentui/react/runtime-plugin-support"
+```
+
+Use this for both normal Bun runs and standalone compiled executables.
+
+## Components
+
+OpenTUI React provides JSX intrinsic elements that map to core renderables:
+
+### Layout & display
+
+- `<text>` - Text display with styling
+- `<box>` - Container with borders and layout
+- `<scrollbox>` - Scrollable container
+- `<ascii-font>` - ASCII art text
+
+### Input
+
+- `<input>` - Single-line text input
+- `<textarea>` - Multi-line text input
+- `<select>` - Selection list
+- `<tab-select>` - Tab-based selection
+
+### Code & diff
+
+- `<code>` - Syntax-highlighted code
+- `<line-number>` - Line numbers with diff/diagnostic support
+- `<diff>` - Unified or split diff viewer
+- `<markdown>` - Markdown rendering
+
+### Text modifiers
+
+Use inside `<text>` components:
+
+- `<span>` - Inline styled text
+- `<strong>`, `<b>` - Bold text
+- `<em>`, `<i>` - Italic text
+- `<u>` - Underlined text
+- `<br>` - Line break
+- `<a>` - Link text
+
+## API reference
+
+### `createRoot(renderer)`
+
+Creates a React root for rendering into the terminal.
+
+```tsx
+import { createCliRenderer } from "@opentui/core"
+import { createRoot } from "@opentui/react"
+
+const renderer = await createCliRenderer()
+createRoot(renderer).render(<App />)
+```
+
+For plugin slots, see [Plugin Slots overview](/docs/plugins/slots) and [React slots](/docs/plugins/react).
+
+## Hooks
+
+### `useRenderer()`
+
+Access the OpenTUI renderer instance.
+
+```tsx
+import { useRenderer } from "@opentui/react"
+import { useEffect } from "react"
+
+function App() {
+  const renderer = useRenderer()
+
+  useEffect(() => {
+    renderer.console.show()
+    console.log("Hello from console!")
+  }, [])
+
+  return <box />
+}
+```
+
+### `useKeyboard(handler, options?)`
+
+Handle keyboard events.
+
+```tsx
+import { useKeyboard, useRenderer } from "@opentui/react"
+
+function App() {
+  const renderer = useRenderer()
+
+  useKeyboard((key) => {
+    if (key.name === "escape") {
+      renderer.destroy()
+    }
+  })
+
+  return <text>Press ESC to close</text>
+}
+```
+
+To handle release events:
+
+```tsx
+useKeyboard(
+  (event) => {
+    if (event.eventType === "release") {
+      console.log("Key released:", event.name)
+    } else {
+      console.log("Key pressed:", event.name)
+    }
+  },
+  { release: true },
+)
+```
+
+### `useOnResize(callback)`
+
+Handle terminal resize events.
+
+```tsx
+import { useOnResize } from "@opentui/react"
+
+function App() {
+  useOnResize((width, height) => {
+    console.log(`Resized to ${width}x${height}`)
+  })
+
+  return <text>Resize-aware component</text>
+}
+```
+
+### `useTerminalDimensions()`
+
+Get reactive terminal dimensions.
+
+```tsx
+import { useTerminalDimensions } from "@opentui/react"
+
+function App() {
+  const { width, height } = useTerminalDimensions()
+
+  return (
+    <text>
+      Terminal: {width}x{height}
+    </text>
+  )
+}
+```
+
+### `usePaste(handler)`
+
+Handle terminal paste events (bracketed paste).
+
+```tsx
+import { decodePasteBytes } from "@opentui/core"
+import { usePaste } from "@opentui/react"
+
+function App() {
+  usePaste((event) => {
+    const text = decodePasteBytes(event.bytes)
+    console.log("Pasted text:", text)
+  })
+
+  return <text>Paste something into the terminal</text>
+}
+```
+
+### `useFocus(handler)`
+
+Subscribe to terminal window focus events.
+
+```tsx
+import { useFocus } from "@opentui/react"
+
+function App() {
+  useFocus(() => {
+    console.log("Terminal gained focus")
+  })
+
+  return <text>Focus-aware component</text>
+}
+```
+
+### `useBlur(handler)`
+
+Subscribe to terminal window blur events.
+
+```tsx
+import { useBlur } from "@opentui/react"
+
+function App() {
+  useBlur(() => {
+    console.log("Terminal lost focus")
+  })
+
+  return <text>Blur-aware component</text>
+}
+```
+
+### `useSelectionHandler(handler)`
+
+Handle text selection events (e.g., mouse drag selection).
+
+```tsx
+import { useSelectionHandler } from "@opentui/react"
+
+function App() {
+  useSelectionHandler((selection) => {
+    const text = selection.getSelectedText()
+    console.log("Selected:", text)
+  })
+
+  return <text selectable>Select this text with your mouse</text>
+}
+```
+
+### `useTimeline(options?)`
+
+Create and manage animations.
+
+```tsx
+import { useTimeline } from "@opentui/react"
+import { useEffect, useState } from "react"
+
+function App() {
+  const [width, setWidth] = useState(0)
+
+  const timeline = useTimeline({
+    duration: 2000,
+    loop: false,
+  })
+
+  useEffect(() => {
+    timeline.add(
+      { width },
+      {
+        width: 50,
+        duration: 2000,
+        ease: "linear",
+        onUpdate: (animation) => {
+          setWidth(animation.targets[0].width)
+        },
+      },
+    )
+  }, [])
+
+  return <box style={{ width, backgroundColor: "#6a5acd" }} />
+}
+```
+
+**Options:**
+
+- `duration` - Animation duration in ms (default: 1000)
+- `loop` - Whether to loop (default: false)
+- `autoplay` - Auto-start (default: true)
+- `onComplete` - Completion callback
+- `onPause` - Pause callback
+
+## Styling
+
+Style components with props or the `style` prop:
+
+```tsx
+// Direct props
+<box backgroundColor="blue" padding={2}>
+  <text>Hello</text>
+</box>
+
+// Style prop
+<box style={{ backgroundColor: "blue", padding: 2 }}>
+  <text>Hello</text>
+</box>
+```
+
+## Example: Login form
+
+```tsx
+import { createCliRenderer } from "@opentui/core"
+import { createRoot, useKeyboard } from "@opentui/react"
+import { useCallback, useState } from "react"
+
+function App() {
+  const [username, setUsername] = useState("")
+  const [password, setPassword] = useState("")
+  const [focused, setFocused] = useState<"username" | "password">("username")
+  const [status, setStatus] = useState("idle")
+
+  useKeyboard((key) => {
+    if (key.name === "tab") {
+      setFocused((prev) => (prev === "username" ? "password" : "username"))
+    }
+  })
+
+  const handleSubmit = useCallback(() => {
+    if (username === "admin" && password === "secret") {
+      setStatus("success")
+    } else {
+      setStatus("error")
+    }
+  }, [username, password])
+
+  return (
+    <box style={{ border: true, padding: 2, flexDirection: "column", gap: 1 }}>
+      <text fg="#FFFF00">Login Form</text>
+
+      <box title="Username" style={{ border: true, width: 40, height: 3 }}>
+        <input
+          placeholder="Enter username..."
+          onInput={setUsername}
+          onSubmit={handleSubmit}
+          focused={focused === "username"}
+        />
+      </box>
+
+      <box title="Password" style={{ border: true, width: 40, height: 3 }}>
+        <input
+          placeholder="Enter password..."
+          onInput={setPassword}
+          onSubmit={handleSubmit}
+          focused={focused === "password"}
+        />
+      </box>
+
+      <text fg={status === "success" ? "green" : status === "error" ? "red" : "#999"}>{status.toUpperCase()}</text>
+    </box>
+  )
+}
+
+const renderer = await createCliRenderer()
+createRoot(renderer).render(<App />)
+```
+
+## Component extension
+
+Register custom renderables as JSX elements:
+
+```tsx
+import { BoxRenderable, createCliRenderer, type BoxOptions, type RenderContext } from "@opentui/core"
+import { createRoot, extend } from "@opentui/react"
+
+class ConsoleButtonRenderable extends BoxRenderable {
+  private _label: string = "Button"
+
+  constructor(ctx: RenderContext, options: BoxOptions & { label?: string }) {
+    super(ctx, options)
+    if (options.label) this._label = options.label
+    this.borderStyle = "single"
+    this.padding = 2
+  }
+
+  get label(): string {
+    return this._label
+  }
+
+  set label(value: string) {
+    this._label = value
+    this.requestRender()
+  }
+}
+
+// Add TypeScript support
+declare module "@opentui/react" {
+  interface OpenTUIComponents {
+    consoleButton: typeof ConsoleButtonRenderable
+  }
+}
+
+// Register the component
+extend({ consoleButton: ConsoleButtonRenderable })
+
+// Use in JSX
+function App() {
+  return <consoleButton label="Click me!" style={{ border: true, backgroundColor: "green" }} />
+}
+
+const renderer = await createCliRenderer()
+createRoot(renderer).render(<App />)
+```
+
+## React DevTools
+
+OpenTUI React supports React DevTools for debugging:
+
+1. Install:
+
+```bash
+bun add --dev react-devtools-core@7
+```
+
+2. Start DevTools:
+
+```bash
+npx react-devtools@7
+```
+
+3. Run with DEV flag:
+
+```bash
+DEV=true bun run your-app.ts
+```
diff --git a/.agents/skills/opentui/docs/bindings/solid.mdx b/.agents/skills/opentui/docs/bindings/solid.mdx
new file mode 100644
index 0000000..aa40329
--- /dev/null
+++ b/.agents/skills/opentui/docs/bindings/solid.mdx
@@ -0,0 +1,500 @@
+---
+title: Solid.js
+description: Build terminal UIs with Solid.js and OpenTUI
+order: 1
+skill:
+  entry: true
+  intents: [solid, jsx, signals, hooks, keyboard, animation, testing]
+---
+
+# Solid.js bindings
+
+Build terminal user interfaces with Solid.js's fine-grained reactivity and OpenTUI.
+
+## Installation
+
+```bash
+bun install solid-js @opentui/solid
+```
+
+## Setup
+
+### 1. Configure TypeScript
+
+Add JSX config to `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid"
+  }
+}
+```
+
+### 2. Configure Bun
+
+Add preload script to `bunfig.toml`:
+
+```toml
+preload = ["@opentui/solid/preload"]
+```
+
+### 3. Enable runtime-loaded plugin support (if needed)
+
+If your app loads external TS/TSX modules at runtime (for example a file-based plugin system), import this once in your entry file before dynamic imports:
+
+```ts
+import "@opentui/solid/runtime-plugin-support"
+```
+
+### 4. Create your app
+
+```tsx
+import { render } from "@opentui/solid"
+
+const App = () => <text>Hello, World!</text>
+
+render(App)
+```
+
+Run with `bun index.tsx`.
+
+## Components
+
+OpenTUI Solid provides JSX intrinsic elements that map to core renderables.
+
+**Note:** Solid uses snake_case for multi-word component names (e.g., `ascii_font`, `tab_select`).
+
+### Layout & display
+
+- `<text>` - Styled text container
+- `<box>` - Layout container with borders
+- `<scrollbox>` - Scrollable container
+- `<ascii_font>` - ASCII art text
+- `<markdown>` - Render Markdown content
+
+### Input
+
+- `<input>` - Single-line text input
+- `<textarea>` - Multi-line text input
+- `<select>` - List selection
+- `<tab_select>` - Tab-based selection
+
+### Code & diff
+
+- `<code>` - Syntax-highlighted code
+- `<line_number>` - Line numbers with diff/diagnostic support
+- `<diff>` - Unified or split diff viewer
+
+### Text modifiers
+
+Use inside `<text>` components:
+
+- `<span>` - Inline styled text
+- `<strong>`, `<b>` - Bold text
+- `<em>`, `<i>` - Italic text
+- `<u>` - Underlined text
+- `<br>` - Line break
+- `<a>` - Link text with href
+
+## API reference
+
+### `render(node, rendererOrConfig?)`
+
+Render a Solid component tree into a CLI renderer.
+
+```tsx
+import { render } from "@opentui/solid"
+
+// Simple usage
+render(() => <App />)
+
+// With renderer config
+render(() => <App />, {
+  targetFps: 30,
+  exitOnCtrlC: false,
+})
+```
+
+**Parameters:**
+
+- `node` - Function returning a JSX element
+- `rendererOrConfig` - Optional `CliRenderer` instance or `CliRendererConfig`
+
+### `testRender(node, options?)`
+
+Create a test renderer for snapshots and interaction tests.
+
+```tsx
+import { testRender } from "@opentui/solid"
+
+const testSetup = await testRender(() => <App />, { width: 40, height: 10 })
+```
+
+### `extend(components)`
+
+Register custom renderables as JSX intrinsic elements.
+
+```tsx
+import { extend } from "@opentui/solid"
+
+extend({ custom_box: CustomBoxRenderable })
+```
+
+### `getComponentCatalogue()`
+
+Returns the current component catalogue that powers JSX tag lookup.
+
+For plugin slots, see [Plugin Slots overview](/docs/plugins/slots) and [Solid slots](/docs/plugins/solid).
+
+## Scrollback writers
+
+In [`split-footer`](/docs/core-concepts/renderer#split-footer) mode with `externalOutputMode: "capture-stdout"`, the Solid binding provides helpers that append JSX-rendered output above the footer. They wrap [`renderer.writeToScrollback`](/docs/core-concepts/renderer#writing-to-scrollback) so you can write scrollback content with signals and components.
+
+### `writeSolidToScrollback(renderer, node, options?)`
+
+Render a JSX node once and append it as a scrollback commit.
+
+```tsx
+import { writeSolidToScrollback } from "@opentui/solid"
+
+writeSolidToScrollback(renderer, () => <text fg="#8BD5CA">api responded in 12ms</text>)
+```
+
+### `createScrollbackWriter(node, options?)`
+
+If you need to pass the same JSX rendering to multiple `writeToScrollback` calls (or hold onto the writer inside your own code), use the lower-level factory:
+
+```tsx
+import { createScrollbackWriter } from "@opentui/solid"
+
+const writer = createScrollbackWriter(() => <text>logged at {new Date().toISOString()}</text>, { startOnNewLine: true })
+
+renderer.writeToScrollback(writer)
+```
+
+### Options
+
+| Option            | Type      | Default        | Description                                                              |
+| ----------------- | --------- | -------------- | ------------------------------------------------------------------------ |
+| `width`           | `number`  | renderer width | Override the snapshot width in columns                                   |
+| `height`          | `number`  | measured auto  | Override the snapshot height in rows (otherwise measured from layout)    |
+| `rowColumns`      | `number`  | snapshot width | Explicit last-row column count for tail tracking                         |
+| `startOnNewLine`  | `boolean` | `true`         | Insert a newline before this commit if the previous commit ended mid-row |
+| `trailingNewline` | `boolean` | -              | Append a newline after the final row                                     |
+
+The writer returns a `ScrollbackSnapshot` whose teardown disposes the inner Solid subtree after the snapshot renders. Use the core [`ScrollbackSurface`](/docs/core-concepts/renderer#writing-to-scrollback) APIs directly if you need streaming commits that re-render the same tree over time.
+
+## Hooks
+
+### `useRenderer()`
+
+Access the OpenTUI renderer instance.
+
+```tsx
+import { useRenderer } from "@opentui/solid"
+import { onMount } from "solid-js"
+
+const App = () => {
+  const renderer = useRenderer()
+
+  onMount(() => {
+    renderer.console.show()
+    console.log("Hello from console!")
+  })
+
+  return <box />
+}
+```
+
+### `useKeyboard(handler, options?)`
+
+Subscribe to keyboard events.
+
+```tsx
+import { useKeyboard, useRenderer } from "@opentui/solid"
+
+const App = () => {
+  const renderer = useRenderer()
+
+  useKeyboard((key) => {
+    if (key.name === "escape") {
+      renderer.destroy()
+    }
+  })
+
+  return <text>Press ESC to close</text>
+}
+```
+
+With release events:
+
+```tsx
+import { createSignal } from "solid-js"
+
+const App = () => {
+  const [pressedKeys, setPressedKeys] = createSignal(new Set<string>())
+
+  useKeyboard(
+    (event) => {
+      setPressedKeys((keys) => {
+        const newKeys = new Set(keys)
+        if (event.eventType === "release") {
+          newKeys.delete(event.name)
+        } else {
+          newKeys.add(event.name)
+        }
+        return newKeys
+      })
+    },
+    { release: true },
+  )
+
+  return <text>Pressed: {Array.from(pressedKeys()).join(", ") || "none"}</text>
+}
+```
+
+### `onResize(callback)`
+
+Handle terminal resize events.
+
+```tsx
+import { onResize } from "@opentui/solid"
+
+const App = () => {
+  onResize((width, height) => {
+    console.log(`Resized to ${width}x${height}`)
+  })
+
+  return <text>Resize-aware component</text>
+}
+```
+
+### `onFocus(callback)`
+
+Run side effects when the terminal window gains focus.
+
+```tsx
+import { onFocus } from "@opentui/solid"
+
+const App = () => {
+  onFocus(() => {
+    console.log("Terminal focused")
+  })
+
+  return <text>Switch away and back to trigger focus events</text>
+}
+```
+
+### `onBlur(callback)`
+
+Run side effects when the terminal window loses focus.
+
+```tsx
+import { onBlur } from "@opentui/solid"
+
+const App = () => {
+  onBlur(() => {
+    console.log("Terminal blurred")
+  })
+
+  return <text>Switch away and back to trigger blur events</text>
+}
+```
+
+These hooks listen for terminal focus-in/focus-out events when the terminal emulator supports them.
+
+### `useTerminalDimensions()`
+
+Get reactive terminal dimensions (returns a Solid signal).
+
+```tsx
+import { useTerminalDimensions } from "@opentui/solid"
+
+const App = () => {
+  const dimensions = useTerminalDimensions()
+
+  return (
+    <text>
+      Terminal: {dimensions().width}x{dimensions().height}
+    </text>
+  )
+}
+```
+
+### `usePaste(handler)`
+
+Subscribe to paste events.
+
+```tsx
+import { usePaste } from "@opentui/solid"
+
+const textDecoder = new TextDecoder()
+
+const App = () => {
+  usePaste((event) => {
+    console.log("Pasted:", textDecoder.decode(event.bytes))
+  })
+
+  return <text>Paste something!</text>
+}
+```
+
+### `useSelectionHandler(callback)`
+
+Handle text selection events.
+
+```tsx
+import { useSelectionHandler } from "@opentui/solid"
+
+const App = () => {
+  useSelectionHandler((selection) => {
+    console.log("Selected:", selection)
+  })
+
+  return <text selectable>Select me!</text>
+}
+```
+
+### `useTimeline(options?)`
+
+Create and manage animations.
+
+```tsx
+import { useTimeline } from "@opentui/solid"
+import { createSignal, onMount } from "solid-js"
+
+const App = () => {
+  const [width, setWidth] = createSignal(0)
+
+  const timeline = useTimeline({
+    duration: 2000,
+    loop: false,
+  })
+
+  onMount(() => {
+    timeline.add(
+      { width: width() },
+      {
+        width: 50,
+        duration: 2000,
+        ease: "linear",
+        onUpdate: (animation) => {
+          setWidth(animation.targets[0].width)
+        },
+      },
+    )
+  })
+
+  return <box style={{ width: width(), backgroundColor: "#6a5acd" }} />
+}
+```
+
+## Special components
+
+### `Portal`
+
+Render children into a different mount point (useful for modals and overlays).
+
+```tsx
+import { Portal, useRenderer } from "@opentui/solid"
+
+const App = () => {
+  const renderer = useRenderer()
+
+  return (
+    <box>
+      <text>Main content</text>
+      <Portal mount={renderer.root}>
+        <box border>Overlay</box>
+      </Portal>
+    </box>
+  )
+}
+```
+
+### `Dynamic`
+
+Render arbitrary intrinsic elements or components dynamically.
+
+```tsx
+import { Dynamic } from "@opentui/solid"
+import { createSignal } from "solid-js"
+
+const App = () => {
+  const [isMultiline, setIsMultiline] = createSignal(false)
+
+  return <Dynamic component={isMultiline() ? "textarea" : "input"} />
+}
+```
+
+## Building for production
+
+Use [Bun.build](https://bun.sh/docs/bundler) with the Solid plugin:
+
+```ts
+import solidPlugin from "@opentui/solid/bun-plugin"
+
+await Bun.build({
+  entrypoints: ["./index.tsx"],
+  target: "bun",
+  outdir: "./build",
+  plugins: [solidPlugin],
+})
+```
+
+To compile to a standalone executable:
+
+```ts
+await Bun.build({
+  entrypoints: ["./index.tsx"],
+  plugins: [solidPlugin],
+  compile: {
+    target: "bun-darwin-arm64",
+    outfile: "./app-macos",
+  },
+})
+```
+
+If that executable loads external plugins/modules at runtime, keep `import "@opentui/solid/runtime-plugin-support"` in your app entry.
+
+## Example: counter
+
+```tsx
+import { render, useKeyboard, useRenderer } from "@opentui/solid"
+import { createSignal } from "solid-js"
+
+const App = () => {
+  const [count, setCount] = createSignal(0)
+  const renderer = useRenderer()
+
+  useKeyboard((key) => {
+    if (key.name === "up") setCount((c) => c + 1)
+    if (key.name === "down") setCount((c) => c - 1)
+    if (key.name === "escape") renderer.destroy()
+  })
+
+  return (
+    <box border padding={2}>
+      <text>Count: {count()}</text>
+      <text fg="#888">Up/Down to change, ESC to close</text>
+    </box>
+  )
+}
+
+render(App)
+```
+
+## Differences from React bindings
+
+| Aspect             | Solid                                                  | React                                  |
+| ------------------ | ------------------------------------------------------ | -------------------------------------- |
+| Render function    | `render(() => <App />)`                                | `createRoot(renderer).render(<App />)` |
+| Component naming   | snake_case (`ascii_font`)                              | kebab-case (`ascii-font`)              |
+| State              | `createSignal`                                         | `useState`                             |
+| Effects            | `onMount`, `onCleanup`                                 | `useEffect`                            |
+| Resize hook        | `onResize(callback)`                                   | `useOnResize(callback)`                |
+| Dimensions         | Returns signal: `dimensions().width`                   | Returns object: `dimensions.width`     |
+| Extra hooks        | `onFocus`, `onBlur`, `usePaste`, `useSelectionHandler` | -                                      |
+| Special components | `Portal`, `Dynamic`                                    | -                                      |
diff --git a/.agents/skills/opentui/docs/components/ascii-font.mdx b/.agents/skills/opentui/docs/components/ascii-font.mdx
new file mode 100644
index 0000000..9ef97ef
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/ascii-font.mdx
@@ -0,0 +1,191 @@
+---
+title: ASCIIFont
+description: Display text using ASCII art fonts
+order: 14
+---
+
+# ASCIIFont
+
+Display text using ASCII art fonts with multiple font styles available. Great for titles, headers, and decorative text.
+
+## Basic Usage
+
+### Renderable API
+
+```typescript
+import { ASCIIFontRenderable, RGBA, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const title = new ASCIIFontRenderable(renderer, {
+  id: "title",
+  text: "OPENTUI",
+  font: "tiny",
+  color: RGBA.fromInts(255, 255, 255, 255),
+})
+
+renderer.root.add(title)
+```
+
+### Construct API
+
+```typescript
+import { ASCIIFont, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+renderer.root.add(
+  ASCIIFont({
+    text: "HELLO",
+    font: "block",
+    color: "#00FF00",
+  }),
+)
+```
+
+## Available Fonts
+
+OpenTUI includes several ASCII art font styles:
+
+```typescript
+// Small, compact font
+{
+  font: "tiny"
+}
+
+// Block style font
+{
+  font: "block"
+}
+
+// Shaded style font
+{
+  font: "shade"
+}
+
+// Slick style font
+{
+  font: "slick"
+}
+
+// Large font
+{
+  font: "huge"
+}
+
+// Grid style font
+{
+  font: "grid"
+}
+
+// Pallet style font
+{
+  font: "pallet"
+}
+```
+
+## Positioning
+
+Position the ASCII text anywhere on screen:
+
+```typescript
+const title = new ASCIIFontRenderable(renderer, {
+  id: "title",
+  text: "TITLE",
+  font: "block",
+  color: RGBA.fromHex("#FFFF00"),
+  x: 10,
+  y: 2,
+})
+```
+
+## Properties
+
+| Property          | Type                         | Default         | Description                |
+| ----------------- | ---------------------------- | --------------- | -------------------------- |
+| `text`            | `string`                     | `""`            | Text to display            |
+| `font`            | `ASCIIFontName`              | `"tiny"`        | Font style to use          |
+| `color`           | `ColorInput \| ColorInput[]` | `"#FFFFFF"`     | Text color(s)              |
+| `backgroundColor` | `ColorInput`                 | `"transparent"` | Background color           |
+| `selectable`      | `boolean`                    | `true`          | Whether text is selectable |
+| `selectionBg`     | `ColorInput`                 | -               | Selection background color |
+| `selectionFg`     | `ColorInput`                 | -               | Selection foreground color |
+| `x`               | `number`                     | -               | X position offset          |
+| `y`               | `number`                     | -               | Y position offset          |
+
+## Example: Welcome Screen
+
+```typescript
+import { Box, ASCIIFont, Text, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const welcomeScreen = Box(
+  {
+    width: "100%",
+    height: "100%",
+    flexDirection: "column",
+    alignItems: "center",
+    justifyContent: "center",
+  },
+  ASCIIFont({
+    text: "OPENTUI",
+    font: "huge",
+    color: "#00FFFF",
+  }),
+  Text({
+    content: "Terminal UI Framework",
+    fg: "#888888",
+  }),
+  Text({
+    content: "Press any key to continue...",
+    fg: "#444444",
+  }),
+)
+
+renderer.root.add(welcomeScreen)
+```
+
+## Dynamic Text
+
+Update the text content dynamically:
+
+```typescript
+const counter = new ASCIIFontRenderable(renderer, {
+  id: "counter",
+  text: "0",
+  font: "block",
+  color: RGBA.fromHex("#FF0000"),
+})
+
+let count = 0
+setInterval(() => {
+  count++
+  counter.text = count.toString()
+}, 1000)
+```
+
+## Color Effects
+
+Create gradient-like effects by positioning multiple ASCII fonts:
+
+```typescript
+import { Box, ASCIIFont } from "@opentui/core"
+
+const gradientTitle = Box(
+  {},
+  ASCIIFont({
+    text: "HELLO",
+    font: "block",
+    color: "#FF0000",
+  }),
+  // Overlay with offset for shadow effect
+  ASCIIFont({
+    text: "HELLO",
+    font: "block",
+    color: "#880000",
+    left: 1,
+    top: 1,
+  }),
+)
+```
diff --git a/.agents/skills/opentui/docs/components/box.mdx b/.agents/skills/opentui/docs/components/box.mdx
new file mode 100644
index 0000000..3228f74
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/box.mdx
@@ -0,0 +1,217 @@
+---
+title: Box
+description: Container component with borders and layout capabilities
+order: 2
+---
+
+# Box
+
+A container component with borders, background colors, and layout capabilities. Use it to create panels, frames, and organized sections.
+
+## Basic usage
+
+### Renderable API
+
+```typescript
+import { BoxRenderable, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const panel = new BoxRenderable(renderer, {
+  id: "panel",
+  width: 30,
+  height: 10,
+  backgroundColor: "#333366",
+  borderStyle: "double",
+  borderColor: "#FFFFFF",
+})
+
+renderer.root.add(panel)
+```
+
+### Construct API
+
+```typescript
+import { Box, Text, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+renderer.root.add(
+  Box(
+    {
+      width: 30,
+      height: 10,
+      backgroundColor: "#333366",
+      borderStyle: "rounded",
+    },
+    Text({ content: "Inside the box!" }),
+  ),
+)
+```
+
+## Border styles
+
+```typescript
+// No border
+{
+  border: false
+}
+
+// Simple border (default style)
+{
+  border: true
+}
+
+// Specific border styles
+{
+  borderStyle: "single"
+} // Single line: ┌─┐│└─┘
+{
+  borderStyle: "double"
+} // Double line: ╔═╗║╚═╝
+{
+  borderStyle: "rounded"
+} // Rounded corners: ╭─╮│╰─╯
+{
+  borderStyle: "heavy"
+} // Heavy lines: ┏━┓┃┗━┛
+```
+
+## Titles
+
+Add a title and bottom title to the box border:
+
+```typescript
+const panel = new BoxRenderable(renderer, {
+  id: "settings",
+  width: 40,
+  height: 15,
+  borderStyle: "rounded",
+  title: "Settings",
+  titleAlignment: "center",
+  bottomTitle: "Footer",
+  bottomTitleAlignment: "center",
+})
+```
+
+### Title alignment (both top and bottom titles)
+
+```typescript
+{
+  titleAlignment: "left"
+} // ┌─ Title ────────┐
+{
+  titleAlignment: "center"
+} // ┌──── Title ─────┐
+{
+  titleAlignment: "right"
+} // ┌────────── Title ┐
+
+{
+  bottomTitleAlignment: "left"
+} // └─ Title ────────┘
+{
+  bottomTitleAlignment: "center"
+} // └──── Title ─────┘
+{
+  bottomTitleAlignment: "right"
+} // └────────── Title ┘
+```
+
+## Layout container
+
+Box works as a flex container for child elements:
+
+```typescript
+const container = Box(
+  {
+    flexDirection: "column",
+    justifyContent: "space-between",
+    alignItems: "stretch",
+    width: 50,
+    height: 20,
+    padding: 1,
+    gap: 1,
+  },
+  Text({ content: "Header" }),
+  Box({ flexGrow: 1, backgroundColor: "#222" }, Text({ content: "Content area" })),
+  Text({ content: "Footer" }),
+)
+```
+
+## Mouse events
+
+Handle mouse interactions on the box:
+
+```typescript
+const button = new BoxRenderable(renderer, {
+  id: "button",
+  width: 12,
+  height: 3,
+  border: true,
+  backgroundColor: "#444",
+  onMouseDown: () => {
+    console.log("Button clicked!")
+  },
+  onMouseOver: () => {
+    button.backgroundColor = "#666"
+  },
+  onMouseOut: () => {
+    button.backgroundColor = "#444"
+  },
+})
+```
+
+## Properties
+
+| Property               | Type               | Default        | Description                       |
+| ---------------------- | ------------------ | -------------- | --------------------------------- |
+| `width`                | `number \| string` | -              | Width in characters or percentage |
+| `height`               | `number \| string` | -              | Height in rows or percentage      |
+| `backgroundColor`      | `string \| RGBA`   | -              | Background fill color             |
+| `border`               | `boolean`          | `false`        | Show border                       |
+| `borderStyle`          | `string`           | `"single"`     | Border style                      |
+| `borderColor`          | `string \| RGBA`   | -              | Border color                      |
+| `title`                | `string`           | -              | Title text in border              |
+| `titleAlignment`       | `string`           | `"left"`       | Title position                    |
+| `bottomTitle`          | `string`           | -              | Bottom title text in border       |
+| `bottomTitleAlignment` | `string`           | `"left"`       | Bottom title position             |
+| `padding`              | `number`           | `0`            | Internal padding                  |
+| `gap`                  | `number \| string` | -              | Gap between children              |
+| `flexDirection`        | `string`           | `"column"`     | Child layout direction            |
+| `justifyContent`       | `string`           | `"flex-start"` | Main axis alignment               |
+| `alignItems`           | `string`           | `"stretch"`    | Cross axis alignment              |
+
+## Example: Card component
+
+```typescript
+import { Box, Text, t, bold, fg } from "@opentui/core"
+
+function Card(props: { title: string; description: string }) {
+  return Box(
+    {
+      width: 40,
+      borderStyle: "rounded",
+      borderColor: "#666",
+      padding: 1,
+      margin: 1,
+    },
+    Text({
+      content: t`${bold(fg("#00FFFF")(props.title))}`,
+    }),
+    Text({
+      content: props.description,
+      fg: "#AAAAAA",
+    }),
+  )
+}
+
+renderer.root.add(
+  Box(
+    { flexDirection: "row", flexWrap: "wrap" },
+    Card({ title: "Feature 1", description: "Description of feature 1" }),
+    Card({ title: "Feature 2", description: "Description of feature 2" }),
+    Card({ title: "Feature 3", description: "Description of feature 3" }),
+  ),
+)
+```
diff --git a/.agents/skills/opentui/docs/components/code.mdx b/.agents/skills/opentui/docs/components/code.mdx
new file mode 100644
index 0000000..92693b1
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/code.mdx
@@ -0,0 +1,280 @@
+---
+title: Code
+description: Syntax-highlighted code display component with Tree-sitter support
+order: 10
+---
+
+# Code
+
+Displays syntax-highlighted code using Tree-sitter. Supports many languages with accurate, fast highlighting.
+
+## Basic usage
+
+### Renderable API
+
+```typescript
+import { CodeRenderable, createCliRenderer, SyntaxStyle, RGBA } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const syntaxStyle = SyntaxStyle.fromStyles({
+  keyword: { fg: RGBA.fromHex("#FF7B72"), bold: true },
+  string: { fg: RGBA.fromHex("#A5D6FF") },
+  comment: { fg: RGBA.fromHex("#8B949E"), italic: true },
+  number: { fg: RGBA.fromHex("#79C0FF") },
+  function: { fg: RGBA.fromHex("#D2A8FF") },
+  default: { fg: RGBA.fromHex("#E6EDF3") },
+})
+
+const code = new CodeRenderable(renderer, {
+  id: "code",
+  content: `function hello() {
+  // This is a comment
+  const message = "Hello, world!"
+  return message
+}`,
+  filetype: "javascript",
+  syntaxStyle,
+  width: 50,
+  height: 10,
+})
+
+renderer.root.add(code)
+```
+
+### Construct API
+
+```typescript
+import { Code, Box, createCliRenderer, SyntaxStyle, RGBA } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const syntaxStyle = SyntaxStyle.fromStyles({
+  keyword: { fg: RGBA.fromHex("#FF7B72"), bold: true },
+  string: { fg: RGBA.fromHex("#A5D6FF") },
+  default: { fg: RGBA.fromHex("#E6EDF3") },
+})
+
+renderer.root.add(
+  Box(
+    { border: true, width: 50, height: 10 },
+    Code({
+      content: 'const x = "hello"',
+      filetype: "javascript",
+      syntaxStyle,
+    }),
+  ),
+)
+```
+
+## Creating syntax styles
+
+Use `SyntaxStyle.fromStyles()` to define colors and attributes for syntax tokens:
+
+```typescript
+import { SyntaxStyle, RGBA, parseColor } from "@opentui/core"
+
+const syntaxStyle = SyntaxStyle.fromStyles({
+  // Basic tokens
+  keyword: { fg: RGBA.fromHex("#FF7B72"), bold: true },
+  "keyword.import": { fg: RGBA.fromHex("#FF7B72"), bold: true },
+  "keyword.operator": { fg: RGBA.fromHex("#FF7B72") },
+
+  string: { fg: RGBA.fromHex("#A5D6FF") },
+  comment: { fg: RGBA.fromHex("#8B949E"), italic: true },
+  number: { fg: RGBA.fromHex("#79C0FF") },
+  boolean: { fg: RGBA.fromHex("#79C0FF") },
+  constant: { fg: RGBA.fromHex("#79C0FF") },
+
+  // Functions and types
+  function: { fg: RGBA.fromHex("#D2A8FF") },
+  "function.call": { fg: RGBA.fromHex("#D2A8FF") },
+  "function.method.call": { fg: RGBA.fromHex("#D2A8FF") },
+  type: { fg: RGBA.fromHex("#FFA657") },
+  constructor: { fg: RGBA.fromHex("#FFA657") },
+
+  // Variables and properties
+  variable: { fg: RGBA.fromHex("#E6EDF3") },
+  "variable.member": { fg: RGBA.fromHex("#79C0FF") },
+  property: { fg: RGBA.fromHex("#79C0FF") },
+
+  // Operators and punctuation
+  operator: { fg: RGBA.fromHex("#FF7B72") },
+  punctuation: { fg: RGBA.fromHex("#F0F6FC") },
+  "punctuation.bracket": { fg: RGBA.fromHex("#F0F6FC") },
+  "punctuation.delimiter": { fg: RGBA.fromHex("#C9D1D9") },
+
+  // Default fallback
+  default: { fg: RGBA.fromHex("#E6EDF3") },
+})
+```
+
+### Style properties
+
+Each style definition can include:
+
+| Property    | Type      | Description             |
+| ----------- | --------- | ----------------------- |
+| `fg`        | `RGBA`    | Foreground (text) color |
+| `bg`        | `RGBA`    | Background color        |
+| `bold`      | `boolean` | Bold text               |
+| `italic`    | `boolean` | Italic text             |
+| `underline` | `boolean` | Underlined text         |
+| `dim`       | `boolean` | Dimmed text             |
+
+## Supported languages
+
+Code uses Tree-sitter for parsing. Tree-sitter supports these languages:
+
+- TypeScript / JavaScript
+- Markdown
+- Zig
+- And any language with a Tree-sitter grammar
+
+## Streaming mode
+
+Enable streaming mode when content arrives incrementally, like LLM output:
+
+```typescript
+const code = new CodeRenderable(renderer, {
+  id: "streaming-code",
+  content: "",
+  filetype: "typescript",
+  syntaxStyle,
+  streaming: true, // Enable streaming mode
+})
+
+// Later, append content
+code.content += "const x = 1\n"
+code.content += "const y = 2\n"
+```
+
+Streaming mode optimizes highlighting for incremental updates.
+
+## Text selection
+
+Enable text selection for copy operations:
+
+```typescript
+const code = new CodeRenderable(renderer, {
+  id: "code",
+  content: sourceCode,
+  filetype: "typescript",
+  syntaxStyle,
+  selectable: true,
+  selectionBg: "#264F78",
+  selectionFg: "#FFFFFF",
+})
+```
+
+## Concealment
+
+The `conceal` option controls whether certain syntax elements (like markdown formatting characters) are hidden:
+
+```typescript
+const code = new CodeRenderable(renderer, {
+  id: "markdown",
+  content: "# Heading\n**bold** text",
+  filetype: "markdown",
+  syntaxStyle,
+  conceal: true, // Hide formatting characters
+})
+```
+
+## With line numbers
+
+Use `LineNumberRenderable` to add line numbers:
+
+```typescript
+import { CodeRenderable, LineNumberRenderable, RGBA, ScrollBoxRenderable, SyntaxStyle } from "@opentui/core"
+
+const sourceCode = "const answer = 42\nconsole.log(answer)\n"
+const syntaxStyle = SyntaxStyle.fromStyles({
+  default: { fg: RGBA.fromHex("#E6EDF3") },
+})
+
+const code = new CodeRenderable(renderer, {
+  id: "code",
+  content: sourceCode,
+  filetype: "typescript",
+  syntaxStyle,
+  width: "100%",
+})
+
+const lineNumbers = new LineNumberRenderable(renderer, {
+  id: "code-with-lines",
+  target: code,
+  minWidth: 3,
+  paddingRight: 1,
+  fg: "#6b7280",
+  bg: "#161b22",
+  width: "100%",
+})
+
+// Wrap in ScrollBox for scrolling
+const scrollbox = new ScrollBoxRenderable(renderer, {
+  id: "scrollbox",
+  width: 60,
+  height: 20,
+})
+scrollbox.add(lineNumbers)
+renderer.root.add(scrollbox)
+```
+
+## Properties
+
+| Property           | Type               | Default  | Description                              |
+| ------------------ | ------------------ | -------- | ---------------------------------------- |
+| `content`          | `string`           | `""`     | Source code to display                   |
+| `filetype`         | `string`           | -        | Language for syntax highlighting         |
+| `syntaxStyle`      | `SyntaxStyle`      | required | Syntax highlighting theme                |
+| `streaming`        | `boolean`          | `false`  | Optimize for incremental content updates |
+| `conceal`          | `boolean`          | `true`   | Hide concealed syntax elements           |
+| `drawUnstyledText` | `boolean`          | `true`   | Show text before highlighting completes  |
+| `treeSitterClient` | `TreeSitterClient` | -        | Custom Tree-sitter client instance       |
+
+### Inherited from TextBufferRenderable
+
+| Property       | Type               | Default  | Description                                 |
+| -------------- | ------------------ | -------- | ------------------------------------------- |
+| `fg`           | `string \| RGBA`   | -        | Default foreground color                    |
+| `bg`           | `string \| RGBA`   | -        | Background color                            |
+| `selectable`   | `boolean`          | `false`  | Enable text selection                       |
+| `selectionBg`  | `string \| RGBA`   | -        | Selection background color                  |
+| `selectionFg`  | `string \| RGBA`   | -        | Selection foreground color                  |
+| `wrapMode`     | `string`           | `"word"` | Text wrapping: `"none"`, `"char"`, `"word"` |
+| `tabIndicator` | `string \| number` | -        | Tab display character or width              |
+
+## Additional properties
+
+| Property         | Type      | Description                                  |
+| ---------------- | --------- | -------------------------------------------- |
+| `lineCount`      | `number`  | Number of lines in content                   |
+| `scrollY`        | `number`  | Current vertical scroll position (get/set)   |
+| `scrollX`        | `number`  | Current horizontal scroll position (get/set) |
+| `scrollWidth`    | `number`  | Total scrollable width (read-only)           |
+| `scrollHeight`   | `number`  | Total scrollable height (read-only)          |
+| `isHighlighting` | `boolean` | Whether highlighting is in progress          |
+| `plainText`      | `string`  | Raw text content                             |
+
+## Markdown styles
+
+For markdown highlighting, use markup-prefixed style names:
+
+```typescript
+const markdownStyle = SyntaxStyle.fromStyles({
+  "markup.heading": { fg: RGBA.fromHex("#58A6FF"), bold: true },
+  "markup.heading.1": { fg: RGBA.fromHex("#00FF88"), bold: true, underline: true },
+  "markup.heading.2": { fg: RGBA.fromHex("#00D7FF"), bold: true },
+  "markup.bold": { fg: RGBA.fromHex("#F0F6FC"), bold: true },
+  "markup.strong": { fg: RGBA.fromHex("#F0F6FC"), bold: true },
+  "markup.italic": { fg: RGBA.fromHex("#F0F6FC"), italic: true },
+  "markup.list": { fg: RGBA.fromHex("#FF7B72") },
+  "markup.quote": { fg: RGBA.fromHex("#8B949E"), italic: true },
+  "markup.raw": { fg: RGBA.fromHex("#A5D6FF") },
+  "markup.raw.block": { fg: RGBA.fromHex("#A5D6FF") },
+  "markup.link": { fg: RGBA.fromHex("#58A6FF"), underline: true },
+  "markup.link.url": { fg: RGBA.fromHex("#58A6FF"), underline: true },
+  default: { fg: RGBA.fromHex("#E6EDF3") },
+})
+```
diff --git a/.agents/skills/opentui/docs/components/diff.mdx b/.agents/skills/opentui/docs/components/diff.mdx
new file mode 100644
index 0000000..ef52e86
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/diff.mdx
@@ -0,0 +1,90 @@
+---
+title: Diff
+description: Unified or split diff viewer
+order: 15
+---
+
+# Diff
+
+Render unified or split diffs with syntax highlighting and optional line numbers.
+
+## Basic usage
+
+### Renderable API
+
+```typescript
+import { DiffRenderable, SyntaxStyle, RGBA, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const syntaxStyle = SyntaxStyle.fromStyles({
+  default: { fg: RGBA.fromHex("#E6EDF3") },
+  string: { fg: RGBA.fromHex("#A5D6FF") },
+  keyword: { fg: RGBA.fromHex("#FF7B72"), bold: true },
+})
+
+const diff = new DiffRenderable(renderer, {
+  id: "diff",
+  width: "100%",
+  height: 16,
+  diff: `diff --git a/app.ts b/app.ts\nindex 1111111..2222222 100644\n--- a/app.ts\n+++ b/app.ts\n@@ -1,3 +1,3 @@\n-const a = 1\n+const a = 2\n`,
+  view: "split",
+  filetype: "typescript",
+  syntaxStyle,
+  showLineNumbers: true,
+})
+
+renderer.root.add(diff)
+```
+
+## Construct API
+
+> Not available yet. Use `DiffRenderable` for now.
+
+## Split view scroll sync
+
+When `view: "split"` is active, you can link the vertical scroll of both panes. Scrolling one pane then moves the other:
+
+```typescript
+const diff = new DiffRenderable(renderer, {
+  id: "diff",
+  view: "split",
+  syncScroll: true,
+  diff: patch,
+  syntaxStyle,
+})
+
+// Toggle at runtime
+diff.syncScroll = false
+```
+
+Scroll sync is a no-op in the unified view.
+
+## Properties
+
+| Property              | Type                            | Default     | Description                           |
+| --------------------- | ------------------------------- | ----------- | ------------------------------------- |
+| `diff`                | `string`                        | `""`        | Unified diff string                   |
+| `view`                | `"unified"` or `"split"`        | `"unified"` | Layout style                          |
+| `syncScroll`          | `boolean`                       | `false`     | Link vertical scroll in split view    |
+| `filetype`            | `string`                        | -           | Syntax highlighting language          |
+| `fg`                  | `string` or `RGBA`              | -           | Base foreground for inner code panes  |
+| `syntaxStyle`         | `SyntaxStyle`                   | -           | Syntax style for code                 |
+| `wrapMode`            | `"word"`, `"char"`, or `"none"` | -           | Code wrapping mode                    |
+| `conceal`             | `boolean`                       | `false`     | Conceal markup when highlighting      |
+| `selectionBg`         | `string` or `RGBA`              | -           | Selection background in code panes    |
+| `selectionFg`         | `string` or `RGBA`              | -           | Selection foreground in code panes    |
+| `treeSitterClient`    | `TreeSitterClient`              | -           | Custom Tree-sitter client             |
+| `showLineNumbers`     | `boolean`                       | `true`      | Show line numbers                     |
+| `lineNumberFg`        | `string` or `RGBA`              | `#888888`   | Line number text color                |
+| `lineNumberBg`        | `string` or `RGBA`              | transparent | Line number background                |
+| `addedLineNumberBg`   | `string` or `RGBA`              | transparent | Line number background for added      |
+| `removedLineNumberBg` | `string` or `RGBA`              | transparent | Line number background for removed    |
+| `addedBg`             | `string` or `RGBA`              | `#1a4d1a`   | Background for added lines            |
+| `removedBg`           | `string` or `RGBA`              | `#4d1a1a`   | Background for removed lines          |
+| `contextBg`           | `string` or `RGBA`              | transparent | Background for context lines          |
+| `addedContentBg`      | `string` or `RGBA`              | -           | Optional content background (added)   |
+| `removedContentBg`    | `string` or `RGBA`              | -           | Optional content background (removed) |
+| `contextContentBg`    | `string` or `RGBA`              | -           | Optional content background (context) |
+| `addedSignColor`      | `string` or `RGBA`              | `#22c55e`   | Sign color for added lines            |
+| `removedSignColor`    | `string` or `RGBA`              | `#ef4444`   | Sign color for removed lines          |
diff --git a/.agents/skills/opentui/docs/components/frame-buffer.mdx b/.agents/skills/opentui/docs/components/frame-buffer.mdx
new file mode 100644
index 0000000..f9301f3
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/frame-buffer.mdx
@@ -0,0 +1,267 @@
+---
+title: FrameBuffer
+description: Low-level rendering surface for custom graphics
+order: 13
+---
+
+# FrameBuffer
+
+A low-level rendering surface for custom graphics and complex visual effects. FrameBuffer provides a 2D array of cells with methods optimized for performance and memory.
+
+## Basic usage
+
+### Renderable API
+
+```typescript
+import { FrameBufferRenderable, RGBA, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const canvas = new FrameBufferRenderable(renderer, {
+  id: "canvas",
+  width: 50,
+  height: 20,
+})
+
+// Draw on the frame buffer
+canvas.frameBuffer.fillRect(5, 2, 20, 10, RGBA.fromHex("#FF0000"))
+canvas.frameBuffer.drawText("Hello!", 8, 6, RGBA.fromHex("#FFFFFF"))
+
+renderer.root.add(canvas)
+```
+
+### Construct API
+
+```typescript
+import { FrameBuffer, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+renderer.root.add(
+  FrameBuffer({
+    width: 50,
+    height: 20,
+  }),
+)
+```
+
+## Drawing methods
+
+### setCell
+
+Set a single cell's content and colors:
+
+```typescript
+canvas.frameBuffer.setCell(
+  x, // X position
+  y, // Y position
+  char, // Character to display
+  fg, // Foreground color (RGBA)
+  bg, // Background color (RGBA)
+  attributes, // Text attributes (optional, default: 0)
+)
+
+// Example
+canvas.frameBuffer.setCell(10, 5, "@", RGBA.fromHex("#FFFF00"), RGBA.fromHex("#000000"))
+```
+
+### setCellWithAlphaBlending
+
+Set a cell with alpha blending for transparency effects:
+
+```typescript
+const semiTransparent = RGBA.fromValues(1.0, 0.0, 0.0, 0.5)
+const transparent = RGBA.fromValues(0, 0, 0, 0)
+canvas.frameBuffer.setCellWithAlphaBlending(10, 5, " ", transparent, semiTransparent)
+```
+
+### drawText
+
+Draw a string of text at a position:
+
+```typescript
+canvas.frameBuffer.drawText(
+  text, // String to draw
+  x, // Starting X position
+  y, // Y position
+  fg, // Text color (RGBA)
+  bg, // Background color (RGBA, optional)
+  attributes, // Text attributes (optional, default: 0)
+)
+
+// Example
+canvas.frameBuffer.drawText("Score: 100", 2, 1, RGBA.fromHex("#00FF00"))
+```
+
+### fillRect
+
+Fill a rectangular area with a color:
+
+```typescript
+canvas.frameBuffer.fillRect(
+  x, // X position
+  y, // Y position
+  width, // Rectangle width
+  height, // Rectangle height
+  color, // Fill color (RGBA)
+)
+
+// Example: Draw a red rectangle
+canvas.frameBuffer.fillRect(10, 5, 20, 8, RGBA.fromHex("#FF0000"))
+```
+
+### drawFrameBuffer
+
+Copy another frame buffer onto this one:
+
+```typescript
+canvas.frameBuffer.drawFrameBuffer(
+  destX, // Destination X
+  destY, // Destination Y
+  sourceBuffer, // Source FrameBuffer (OptimizedBuffer)
+  sourceX, // Source X offset (optional)
+  sourceY, // Source Y offset (optional)
+  sourceWidth, // Width to copy (optional)
+  sourceHeight, // Height to copy (optional)
+)
+```
+
+### colorMatrix / colorMatrixUniform
+
+Apply native 4x4 RGBA matrix transforms for post-processing effects. Use `colorMatrixUniform` for full-buffer
+transforms, and `colorMatrix` when you want to target specific cells.
+
+```typescript
+import { INVERT_MATRIX, TargetChannel } from "@opentui/core"
+
+// Full-buffer transform
+canvas.frameBuffer.colorMatrixUniform(INVERT_MATRIX, 1.0, TargetChannel.Both)
+
+// Per-cell transform with explicit mask
+const cellMask = new Float32Array([10, 5, 1.0, 11, 5, 0.5])
+canvas.frameBuffer.colorMatrix(INVERT_MATRIX, cellMask, 1.0, TargetChannel.FG)
+```
+
+See [Color matrix reference](/docs/reference/color-matrix) for matrix layout, mask format, and behavior details.
+
+## Properties
+
+| Property                         | Type      | Default      | Description                           |
+| -------------------------------- | --------- | ------------ | ------------------------------------- |
+| `width`                          | `number`  | -            | Buffer width in characters (required) |
+| `height`                         | `number`  | -            | Buffer height in rows (required)      |
+| `respectAlpha`                   | `boolean` | `false`      | Enable alpha blending when drawing    |
+| `position`                       | `string`  | `"relative"` | Positioning mode                      |
+| `left`, `top`, `right`, `bottom` | `number`  | -            | Position offsets                      |
+
+## Example: Simple game canvas
+
+```typescript
+import { FrameBufferRenderable, RGBA, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const gameCanvas = new FrameBufferRenderable(renderer, {
+  id: "game",
+  width: 40,
+  height: 20,
+  position: "absolute",
+  left: 5,
+  top: 2,
+})
+
+// Game state
+let playerX = 20
+let playerY = 10
+
+function render() {
+  const fb = gameCanvas.frameBuffer
+  const BG = RGBA.fromHex("#111111")
+
+  // Clear the canvas
+  fb.fillRect(0, 0, 40, 20, BG)
+
+  // Draw border
+  for (let x = 0; x < 40; x++) {
+    fb.setCell(x, 0, "-", RGBA.fromHex("#444444"), BG)
+    fb.setCell(x, 19, "-", RGBA.fromHex("#444444"), BG)
+  }
+  for (let y = 0; y < 20; y++) {
+    fb.setCell(0, y, "|", RGBA.fromHex("#444444"), BG)
+    fb.setCell(39, y, "|", RGBA.fromHex("#444444"), BG)
+  }
+
+  // Draw player
+  fb.setCell(playerX, playerY, "@", RGBA.fromHex("#00FF00"), BG)
+
+  // Draw score
+  fb.drawText("Score: 0", 2, 0, RGBA.fromHex("#FFFF00"))
+}
+
+// Handle input
+renderer.keyInput.on("keypress", (key) => {
+  switch (key.name) {
+    case "up":
+      playerY = Math.max(1, playerY - 1)
+      break
+    case "down":
+      playerY = Math.min(18, playerY + 1)
+      break
+    case "left":
+      playerX = Math.max(1, playerX - 1)
+      break
+    case "right":
+      playerX = Math.min(38, playerX + 1)
+      break
+  }
+  render()
+})
+
+render()
+renderer.root.add(gameCanvas)
+```
+
+## Example: Progress bar
+
+```typescript
+const EMPTY_BG = RGBA.fromHex("#222222")
+
+function drawProgressBar(fb, x, y, width, progress, color) {
+  const filled = Math.floor(width * progress)
+
+  // Draw filled portion
+  for (let i = 0; i < filled; i++) {
+    fb.setCell(x + i, y, "█", color, EMPTY_BG)
+  }
+
+  // Draw empty portion
+  for (let i = filled; i < width; i++) {
+    fb.setCell(x + i, y, "░", RGBA.fromHex("#333333"), EMPTY_BG)
+  }
+}
+
+// Usage
+drawProgressBar(canvas.frameBuffer, 5, 10, 30, 0.75, RGBA.fromHex("#00FF00"))
+```
+
+## Performance tips
+
+1. **Batch updates**: Make multiple changes to the frame buffer before the next render cycle
+2. **Minimize fillRect calls**: Use individual setCell calls for complex shapes
+3. **Reuse RGBA objects**: Create color constants instead of calling `fromHex` repeatedly
+
+```typescript
+// Good: Create once, reuse
+const RED = RGBA.fromHex("#FF0000")
+const GREEN = RGBA.fromHex("#00FF00")
+const BG = RGBA.fromHex("#000000")
+
+for (let i = 0; i < 100; i++) {
+  fb.setCell(i, 5, "*", RED, BG)
+}
+
+// Avoid: Creating new RGBA objects in loops
+for (let i = 0; i < 100; i++) {
+  fb.setCell(i, 5, "*", RGBA.fromHex("#FF0000"), RGBA.fromHex("#000000")) // Creates 200 objects
+}
+```
diff --git a/.agents/skills/opentui/docs/components/input.mdx b/.agents/skills/opentui/docs/components/input.mdx
new file mode 100644
index 0000000..ccd3700
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/input.mdx
@@ -0,0 +1,198 @@
+---
+title: Input
+description: Text input field with cursor and focus states
+order: 3
+skill:
+  entry: true
+  intents: [input, form, editing, focus]
+---
+
+# Input
+
+Text input field with cursor, placeholder text, and focus states. Focus the input to receive keyboard input.
+
+## Basic usage
+
+### Renderable api
+
+```typescript
+import { InputRenderable, InputRenderableEvents, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const input = new InputRenderable(renderer, {
+  id: "name-input",
+  width: 25,
+  placeholder: "Enter your name...",
+})
+
+input.on(InputRenderableEvents.CHANGE, (value) => {
+  console.log("Input value:", value)
+})
+
+input.focus()
+renderer.root.add(input)
+```
+
+### Construct api
+
+```typescript
+import { Input, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const input = Input({
+  placeholder: "Enter your name...",
+  width: 25,
+})
+
+input.focus()
+renderer.root.add(input)
+```
+
+## Focus states
+
+The input changes appearance when focused:
+
+```typescript
+const input = new InputRenderable(renderer, {
+  id: "styled-input",
+  width: 30,
+  placeholder: "Type here...",
+  backgroundColor: "#1a1a1a",
+  focusedBackgroundColor: "#2a2a2a",
+  textColor: "#FFFFFF",
+  cursorColor: "#00FF00",
+})
+```
+
+## Events
+
+### Input event
+
+Fires on every keystroke as the value changes:
+
+```typescript
+import { InputRenderableEvents } from "@opentui/core"
+
+input.on(InputRenderableEvents.INPUT, (value: string) => {
+  console.log("Current value:", value)
+})
+```
+
+### Change event
+
+Fires when the input loses focus (blur) or when you press Enter, but only if the value changed since focus:
+
+```typescript
+input.on(InputRenderableEvents.CHANGE, (value: string) => {
+  console.log("Value committed:", value)
+})
+```
+
+### Enter event
+
+Fires when the user presses Enter/Return:
+
+```typescript
+input.on(InputRenderableEvents.ENTER, (value: string) => {
+  console.log("Submitted value:", value)
+})
+```
+
+### Getting the current value
+
+```typescript
+const currentValue = input.value
+```
+
+### Setting the value
+
+```typescript
+input.value = "New value"
+```
+
+## Properties
+
+| Property                 | Type                                   | Default      | Description                  |
+| ------------------------ | -------------------------------------- | ------------ | ---------------------------- |
+| `width`                  | `number`                               | -            | Input field width            |
+| `value`                  | `string`                               | `""`         | Initial text value           |
+| `placeholder`            | `string`                               | `""`         | Placeholder text when empty  |
+| `maxLength`              | `number`                               | `1000`       | Maximum number of characters |
+| `backgroundColor`        | `string \| RGBA`                       | -            | Background when unfocused    |
+| `focusedBackgroundColor` | `string \| RGBA`                       | -            | Background when focused      |
+| `textColor`              | `string \| RGBA`                       | -            | Text color                   |
+| `cursorColor`            | `string \| RGBA`                       | -            | Cursor color                 |
+| `position`               | `"static" \| "relative" \| "absolute"` | `"relative"` | Positioning mode             |
+
+## Example: Login form
+
+```typescript
+import { Box, Text, Input, delegate, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+function LabeledInput(props: { id: string; label: string; placeholder: string }) {
+  return delegate(
+    { focus: `${props.id}-input` },
+    Box(
+      { flexDirection: "row", marginBottom: 1 },
+      Text({ content: props.label.padEnd(12), fg: "#888888" }),
+      Input({
+        id: `${props.id}-input`,
+        placeholder: props.placeholder,
+        width: 20,
+        backgroundColor: "#222",
+        focusedBackgroundColor: "#333",
+        textColor: "#FFF",
+        cursorColor: "#0F0",
+      }),
+    ),
+  )
+}
+
+const usernameInput = LabeledInput({
+  id: "username",
+  label: "Username:",
+  placeholder: "Enter username",
+})
+
+const passwordInput = LabeledInput({
+  id: "password",
+  label: "Password:",
+  placeholder: "Enter password",
+})
+
+const form = Box(
+  {
+    width: 40,
+    borderStyle: "rounded",
+    title: "Login",
+    padding: 1,
+  },
+  usernameInput,
+  passwordInput,
+)
+
+// Focus the username input
+usernameInput.focus()
+
+renderer.root.add(form)
+```
+
+## Tab navigation
+
+Add tab navigation between inputs:
+
+```typescript
+const inputs = [usernameInput, passwordInput]
+let focusIndex = 0
+
+renderer.keyInput.on("keypress", (key) => {
+  if (key.name === "tab") {
+    focusIndex = (focusIndex + 1) % inputs.length
+    inputs[focusIndex].focus()
+  }
+})
+```
diff --git a/.agents/skills/opentui/docs/components/line-number.mdx b/.agents/skills/opentui/docs/components/line-number.mdx
new file mode 100644
index 0000000..528fc06
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/line-number.mdx
@@ -0,0 +1,119 @@
+---
+title: Line numbers
+description: Line number gutter for code and text renderables
+order: 12
+---
+
+# Line numbers
+
+Add a line number gutter to renderables that provide line info, such as `CodeRenderable` and text editor components.
+
+## Basic usage
+
+### Renderable API
+
+```typescript
+import {
+  CodeRenderable,
+  LineNumberRenderable,
+  ScrollBoxRenderable,
+  SyntaxStyle,
+  RGBA,
+  createCliRenderer,
+} from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const syntaxStyle = SyntaxStyle.fromStyles({
+  default: { fg: RGBA.fromHex("#E6EDF3") },
+})
+
+const code = new CodeRenderable(renderer, {
+  id: "code",
+  content: "const x = 1\nconst y = 2\n",
+  filetype: "typescript",
+  syntaxStyle,
+  width: "100%",
+})
+
+const lineNumbers = new LineNumberRenderable(renderer, {
+  id: "code-lines",
+  target: code,
+  minWidth: 3,
+  paddingRight: 1,
+  fg: "#6b7280",
+  bg: "#161b22",
+})
+
+const scrollbox = new ScrollBoxRenderable(renderer, {
+  id: "scrollbox",
+  width: 70,
+  height: 18,
+})
+
+scrollbox.add(lineNumbers)
+renderer.root.add(scrollbox)
+```
+
+## Line signs and colors
+
+Set a single background for a line, or split gutter and content colors separately with a `LineColorConfig` object:
+
+```typescript
+// Shorthand: applies to both gutter and content
+lineNumbers.setLineColor(3, "#2b6cb0")
+
+// Split config: different gutter vs content background
+lineNumbers.setLineColor(3, {
+  gutter: "#2b6cb0",
+  content: "#1f2937",
+})
+
+lineNumbers.setLineSign(3, { before: ">", beforeColor: "#2b6cb0" })
+
+// Clear
+lineNumbers.clearLineColor(3)
+lineNumbers.clearLineSign(3)
+```
+
+## Theming the gutter
+
+Gutter text and background colors accept assignments after construction:
+
+```typescript
+lineNumbers.fg = "#6b7280"
+lineNumbers.bg = "#161b22"
+```
+
+Assign `undefined` to reset to the defaults (`#888888` foreground, transparent background).
+
+## Construct API
+
+> Not available yet. Use `LineNumberRenderable` for now.
+
+## Properties
+
+| Property           | Type                                             | Default     | Description                    |
+| ------------------ | ------------------------------------------------ | ----------- | ------------------------------ |
+| `target`           | `Renderable & LineInfoProvider`                  | -           | Target renderable to number    |
+| `fg`               | `string` or `RGBA`                               | `#888888`   | Gutter text color              |
+| `bg`               | `string` or `RGBA`                               | transparent | Gutter background color        |
+| `minWidth`         | `number`                                         | `3`         | Minimum gutter width           |
+| `paddingRight`     | `number`                                         | `1`         | Right padding for gutter       |
+| `lineColors`       | `Map<number, string \| RGBA \| LineColorConfig>` | -           | Per-line background colors     |
+| `lineSigns`        | `Map<number, LineSign>`                          | -           | Per-line signs (before/after)  |
+| `lineNumberOffset` | `number`                                         | `0`         | Offset for line numbering      |
+| `hideLineNumbers`  | `Set<number>`                                    | -           | Lines to hide numbers for      |
+| `lineNumbers`      | `Map<number, number>`                            | -           | Override line numbers per line |
+| `showLineNumbers`  | `boolean`                                        | `true`      | Toggle gutter visibility       |
+
+## Methods
+
+| Method                 | Description                           |
+| ---------------------- | ------------------------------------- |
+| `setLineColor()`       | Set a background color for a line     |
+| `clearLineColor()`     | Clear a line background color         |
+| `setLineSign()`        | Set a sign before/after a line number |
+| `clearLineSign()`      | Clear a line sign                     |
+| `setLineNumbers()`     | Override multiple line numbers        |
+| `setHideLineNumbers()` | Hide line numbers for specific lines  |
diff --git a/.agents/skills/opentui/docs/components/markdown.mdx b/.agents/skills/opentui/docs/components/markdown.mdx
new file mode 100644
index 0000000..dfa8ba5
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/markdown.mdx
@@ -0,0 +1,196 @@
+---
+title: Markdown
+description: Render markdown with syntax-aware styling
+order: 11
+---
+
+# Markdown
+
+Render markdown content with syntax-aware styling and optional Tree-sitter highlighting for code blocks.
+
+## Basic usage
+
+### Renderable API
+
+````typescript
+import { MarkdownRenderable, SyntaxStyle, RGBA, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const syntaxStyle = SyntaxStyle.fromStyles({
+  "markup.heading.1": { fg: RGBA.fromHex("#58A6FF"), bold: true },
+  "markup.list": { fg: RGBA.fromHex("#FF7B72") },
+  "markup.raw": { fg: RGBA.fromHex("#A5D6FF") },
+  default: { fg: RGBA.fromHex("#E6EDF3") },
+})
+
+const markdown = new MarkdownRenderable(renderer, {
+  id: "readme",
+  width: 60,
+  content: "# Hello\n\n- One\n- Two\n\n```ts\nconst x = 1\n```",
+  syntaxStyle,
+})
+
+renderer.root.add(markdown)
+````
+
+## Fenced language normalization
+
+Code fence info strings are normalized before Tree-sitter highlighting.
+
+- `tsx` -> `typescriptreact`
+- `.jsx` -> `javascriptreact`
+- `TSX title=Button.tsx` -> `typescriptreact`
+- `Dockerfile` -> `dockerfile`
+
+Normalization uses `infoStringToFiletype()`. You can extend or override mappings at runtime:
+
+```typescript
+import { extensionToFiletype, basenameToFiletype } from "@opentui/core"
+
+extensionToFiletype.set("templ", "html")
+basenameToFiletype.set("mytoolrc", "yaml")
+```
+
+## Concealment
+
+Hide markdown markers (backticks, emphasis markers, etc.) when `conceal` is true:
+
+```typescript
+const markdown = new MarkdownRenderable(renderer, {
+  content: "**bold** and `code`",
+  syntaxStyle,
+  conceal: true,
+})
+```
+
+Use `concealCode` to control concealment inside fenced code blocks independently (`false` by default).
+
+## Streaming updates
+
+Enable streaming mode for incremental updates. Keep it `true` while appending chunks, then set `markdown.streaming = false` when complete to finalize trailing block parsing. Tables include trailing partial rows, with missing cells rendered empty.
+
+```typescript
+const markdown = new MarkdownRenderable(renderer, {
+  content: "",
+  syntaxStyle,
+  streaming: true,
+})
+
+markdown.content += "# Live log\n"
+markdown.content += "- line 1\n"
+markdown.streaming = false
+```
+
+### Stable block prefix
+
+`parseMarkdownIncremental` reports how many parsed tokens at the head of the stream are stable — that is, unlikely to change if you append more content. The renderable surfaces this as a count of **top-level render blocks** you can safely commit elsewhere while the unstable tail keeps updating.
+
+To use it, render with `internalBlockMode: "top-level"`. The renderable keeps each top-level markdown block (heading, paragraph, list, table, fenced code) as its own child renderable, and exposes `markdown._stableBlockCount` — the number of blocks at the head of the tree that are stable right now. This matches the shape [`ScrollbackSurface`](/docs/core-concepts/renderer#writing-to-scrollback) expects when you commit streamed output row-by-row.
+
+```typescript
+import { MarkdownRenderable, RGBA, SyntaxStyle } from "@opentui/core"
+
+const syntaxStyle = SyntaxStyle.fromStyles({
+  default: { fg: RGBA.fromHex("#E6EDF3") },
+})
+
+const md = new MarkdownRenderable(renderer, {
+  content: "",
+  syntaxStyle,
+  streaming: true,
+  internalBlockMode: "top-level",
+})
+
+md.content = "# Title\n\nPara 1"
+// md._stableBlockCount might be 1 here — "# Title" is settled, "Para 1" could still grow
+
+md.content = "# Title\n\nPara 1\n\nPara 2"
+// md._stableBlockCount rises as earlier blocks are sealed by a blank line
+```
+
+`internalBlockMode` is an experimental, opt-in flag that powers the built-in scrollback streaming demo. For non-streaming rendering, leave it at the default (`"coalesced"`), which folds sibling blocks together and matches the historical layout.
+
+## Markdown tables
+
+Markdown tables support `tableOptions` for style, sizing, wrapping, borders, and selection.
+
+```typescript
+const markdown = new MarkdownRenderable(renderer, {
+  content: "| Service | Status |\n| --- | --- |\n| api | ok |",
+  syntaxStyle,
+  tableOptions: {
+    style: "grid",
+    widthMode: "full",
+    columnFitter: "balanced",
+    wrapMode: "word",
+    cellPadding: 1,
+    borders: true,
+    outerBorder: true,
+    borderStyle: "rounded",
+    borderColor: "#6b7280",
+    selectable: true,
+  },
+})
+```
+
+### `tableOptions`
+
+| Option         | Type                           | Default                 | Description                                       |
+| -------------- | ------------------------------ | ----------------------- | ------------------------------------------------- |
+| `style`        | `"grid" \| "columns"`          | depends on block mode   | Visual preset (see [Table styles](#table-styles)) |
+| `widthMode`    | `"content" \| "full"`          | depends on style        | `"full"` expands columns to fill available width  |
+| `columnFitter` | `"proportional" \| "balanced"` | `"proportional"`        | How columns shrink when space is constrained      |
+| `wrapMode`     | `"none" \| "char" \| "word"`   | `"word"`                | Wrapping mode inside each table cell              |
+| `cellPadding`  | `number`                       | `0`                     | Padding on all sides of each cell                 |
+| `borders`      | `boolean`                      | depends on style        | Enable inner and outer borders                    |
+| `outerBorder`  | `boolean`                      | `borders`               | Override outer border visibility                  |
+| `borderStyle`  | `BorderStyle`                  | `"single"`              | Table border character set                        |
+| `borderColor`  | `ColorInput`                   | conceal fg or `#888888` | Border color for markdown tables                  |
+| `selectable`   | `boolean`                      | `true`                  | Enable table cell text selection                  |
+
+### Table styles
+
+`tableOptions.style` picks a preset that tunes the defaults for `borders`, `outerBorder`, and `widthMode` together:
+
+- **`"grid"`**: boxed table with visible borders. Defaults to `borders: true`, `widthMode: "full"`. This is the normal markdown-in-a-box rendering.
+- **`"columns"`**: borderless columns with a 2-column gap, defaults to `widthMode: "content"`. Useful for append-only output where a full-width grid feels heavy.
+
+If you do not pass `style`, it defaults to `"columns"` when `internalBlockMode` is `"top-level"`, and `"grid"` otherwise. You can still override individual fields (for example, `borders: true`) to pull toward a different look.
+
+## Custom node rendering
+
+Override rendering for a token and fall back to default rendering:
+
+```typescript
+const markdown = new MarkdownRenderable(renderer, {
+  content: "# Title\n\nHello",
+  syntaxStyle,
+  renderNode: (token, context) => {
+    if (token.type === "heading") {
+      return context.defaultRender()
+    }
+    return undefined
+  },
+})
+```
+
+## Construct API
+
+> Not available yet. Use `MarkdownRenderable` for now.
+
+## Properties
+
+| Property            | Type                                                                            | Default       | Description                                                   |
+| ------------------- | ------------------------------------------------------------------------------- | ------------- | ------------------------------------------------------------- |
+| `content`           | `string`                                                                        | `""`          | Markdown source                                               |
+| `syntaxStyle`       | `SyntaxStyle`                                                                   | required      | Style definitions for tokens                                  |
+| `fg`                | `ColorInput`                                                                    | -             | Base foreground color (flows into inner code blocks)          |
+| `bg`                | `ColorInput`                                                                    | -             | Base background color (flows into inner code blocks)          |
+| `conceal`           | `boolean`                                                                       | `true`        | Hide markdown markers in markdown text                        |
+| `concealCode`       | `boolean`                                                                       | `false`       | Hide markers inside fenced code blocks                        |
+| `streaming`         | `boolean`                                                                       | `false`       | Incremental mode; set `false` to finalize                     |
+| `tableOptions`      | `MarkdownTableOptions`                                                          | -             | Options for markdown table rendering                          |
+| `internalBlockMode` | `"coalesced" \| "top-level"`                                                    | `"coalesced"` | Experimental: expose top-level blocks as separate renderables |
+| `treeSitterClient`  | `TreeSitterClient`                                                              | -             | Custom Tree-sitter client for code blocks                     |
+| `renderNode`        | `(token: Token, context: RenderNodeContext) => Renderable \| null \| undefined` | -             | Custom render hook per markdown block                         |
diff --git a/.agents/skills/opentui/docs/components/scrollbar.mdx b/.agents/skills/opentui/docs/components/scrollbar.mdx
new file mode 100644
index 0000000..3031a92
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/scrollbar.mdx
@@ -0,0 +1,68 @@
+---
+title: ScrollBar
+description: Standalone scrollbar with arrows and keyboard control
+order: 8
+---
+
+# ScrollBar
+
+A standalone scrollbar component with optional arrows, keyboard navigation, and a draggable thumb.
+
+## Basic usage
+
+### Renderable API
+
+```typescript
+import { ScrollBarRenderable, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const scrollbar = new ScrollBarRenderable(renderer, {
+  id: "scrollbar",
+  orientation: "vertical",
+  height: 10,
+  showArrows: true,
+  trackOptions: {
+    backgroundColor: "#222222",
+    foregroundColor: "#888888",
+  },
+  onChange: (position) => {
+    console.log("Scroll position:", position)
+  },
+})
+
+// Connect the scrollbar to your content
+scrollbar.scrollSize = 200
+scrollbar.viewportSize = 20
+scrollbar.scrollPosition = 0
+
+renderer.root.add(scrollbar)
+scrollbar.focus()
+```
+
+## Keyboard controls
+
+When focused, the scrollbar responds to:
+
+- `Up`/`Down` or `k`/`j` for vertical bars
+- `Left`/`Right` or `h`/`l` for horizontal bars
+- `PageUp`/`PageDown` for larger jumps
+- `Home`/`End` to jump to start/end
+
+## Construct API
+
+> Not available yet. Use `ScrollBarRenderable` for now.
+
+## Properties
+
+| Property         | Type                           | Default | Description                            |
+| ---------------- | ------------------------------ | ------- | -------------------------------------- |
+| `orientation`    | `"vertical"` or `"horizontal"` | -       | Scrollbar direction                    |
+| `showArrows`     | `boolean`                      | `false` | Show arrow buttons                     |
+| `arrowOptions`   | `ArrowOptions`                 | -       | Styling for arrow buttons              |
+| `trackOptions`   | `Partial<SliderOptions>`       | -       | Styling for the track and thumb        |
+| `scrollSize`     | `number`                       | `0`     | Total scrollable size                  |
+| `viewportSize`   | `number`                       | `0`     | Visible size of the viewport           |
+| `scrollPosition` | `number`                       | `0`     | Current scroll position                |
+| `scrollStep`     | `number`                       | -       | Step size when `scrollBy(..., "step")` |
+| `onChange`       | `(position: number) => void`   | -       | Fired when scroll position changes     |
diff --git a/.agents/skills/opentui/docs/components/scrollbox.mdx b/.agents/skills/opentui/docs/components/scrollbox.mdx
new file mode 100644
index 0000000..a9cdf54
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/scrollbox.mdx
@@ -0,0 +1,250 @@
+---
+title: ScrollBox
+description: A scrollable container component with customizable scrollbars
+order: 7
+---
+
+# ScrollBox
+
+A scrollable container that supports horizontal and vertical scrolling, sticky scroll behavior, viewport culling, and customizable scrollbars.
+
+## Basic usage
+
+### Renderable api
+
+```typescript
+import { ScrollBoxRenderable, TextRenderable, BoxRenderable, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const scrollbox = new ScrollBoxRenderable(renderer, {
+  id: "scrollbox",
+  width: 40,
+  height: 20,
+})
+
+// Add content to the scrollbox
+for (let i = 0; i < 100; i++) {
+  scrollbox.add(
+    new BoxRenderable(renderer, {
+      id: `item-${i}`,
+      width: "100%",
+      height: 2,
+      backgroundColor: i % 2 === 0 ? "#292e42" : "#2f3449",
+    }),
+  )
+}
+
+renderer.root.add(scrollbox)
+```
+
+### Construct API
+
+```typescript
+import { ScrollBox, Box, Text, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+renderer.root.add(
+  ScrollBox(
+    {
+      width: 40,
+      height: 20,
+    },
+    ...Array.from({ length: 100 }, (_, i) =>
+      Box(
+        { width: "100%", padding: 1, backgroundColor: i % 2 === 0 ? "#292e42" : "#2f3449" },
+        Text({ content: `Item ${i}` }),
+      ),
+    ),
+  ),
+)
+```
+
+## Sticky scroll
+
+Enable sticky scroll to keep content pinned to an edge as new content arrives. Useful for log viewers or chat interfaces.
+
+```typescript
+const scrollbox = new ScrollBoxRenderable(renderer, {
+  id: "logs",
+  width: 60,
+  height: 20,
+  stickyScroll: true,
+  stickyStart: "bottom", // New content will keep the view scrolled to bottom
+})
+```
+
+### Sticky positions
+
+- `"bottom"` - Stay scrolled to bottom (default for chat/logs)
+- `"top"` - Stay scrolled to top
+- `"left"` - Stay scrolled to left
+- `"right"` - Stay scrolled to right
+
+When you scroll away from the sticky position, sticky behavior pauses until you scroll back to the sticky edge.
+
+## Bidirectional scrolling
+
+Enable scrolling in both directions:
+
+```typescript
+const scrollbox = new ScrollBoxRenderable(renderer, {
+  id: "canvas",
+  width: 60,
+  height: 30,
+  scrollX: true,
+  scrollY: true,
+})
+```
+
+By default, `scrollY` is `true` and `scrollX` is `false`.
+
+## Viewport culling
+
+Enable viewport culling for better performance with large content. When enabled, ScrollBox renders only visible children:
+
+```typescript
+const scrollbox = new ScrollBoxRenderable(renderer, {
+  id: "large-list",
+  width: 40,
+  height: 20,
+  viewportCulling: true, // Only render visible items
+})
+```
+
+## Customizing scrollbars
+
+Style the scrollbars using nested options:
+
+```typescript
+const scrollbox = new ScrollBoxRenderable(renderer, {
+  id: "styled-scroll",
+  width: 40,
+  height: 20,
+  scrollbarOptions: {
+    showArrows: true,
+    trackOptions: {
+      foregroundColor: "#7aa2f7",
+      backgroundColor: "#414868",
+    },
+  },
+  // Or customize vertical and horizontal separately
+  verticalScrollbarOptions: {
+    trackOptions: { backgroundColor: "#333" },
+  },
+  horizontalScrollbarOptions: {
+    trackOptions: { backgroundColor: "#333" },
+  },
+})
+```
+
+## Customizing sub-components
+
+ScrollBox contains several internal components that you can style individually:
+
+```typescript
+const scrollbox = new ScrollBoxRenderable(renderer, {
+  id: "custom-scroll",
+  width: 40,
+  height: 20,
+  rootOptions: {
+    backgroundColor: "#24283b",
+  },
+  wrapperOptions: {
+    backgroundColor: "#1f2335",
+  },
+  viewportOptions: {
+    backgroundColor: "#1a1b26",
+  },
+  contentOptions: {
+    backgroundColor: "#16161e",
+  },
+})
+```
+
+## Scroll methods
+
+### scrollBy
+
+Scroll by a relative amount:
+
+```typescript
+// Scroll down 5 lines
+scrollbox.scrollBy(5)
+
+// Scroll with both x and y
+scrollbox.scrollBy({ x: 10, y: 5 })
+
+// Scroll by viewport (page)
+scrollbox.scrollBy(1, "viewport")
+```
+
+### scrollTo
+
+Scroll to an absolute position:
+
+```typescript
+// Scroll to top
+scrollbox.scrollTo(0)
+
+// Scroll to specific position
+scrollbox.scrollTo({ x: 0, y: 100 })
+```
+
+### scrollChildIntoView
+
+Scroll the minimum distance needed to show a nested child in the viewport. The method uses DOM-style "nearest" behavior: if the child already fits, the call is a no-op; otherwise it scrolls to reveal the nearest edge.
+
+```typescript
+scrollbox.scrollChildIntoView("table-row-42")
+```
+
+Use it when you focus an element offscreen (search results, a newly inserted form field, etc.) and want to bring it into view without moving the scroll position more than needed.
+
+## Keyboard navigation
+
+When focused, ScrollBox responds to keyboard input:
+
+- **Arrow keys** - Scroll by line
+- **Page Up/Down** - Scroll by page
+- **Home/End** - Scroll to start/end
+
+## Properties
+
+| Property                     | Type                                     | Default | Description                            |
+| ---------------------------- | ---------------------------------------- | ------- | -------------------------------------- |
+| `scrollX`                    | `boolean`                                | `false` | Enable horizontal scrolling            |
+| `scrollY`                    | `boolean`                                | `true`  | Enable vertical scrolling              |
+| `stickyScroll`               | `boolean`                                | `false` | Keep scroll position pinned to an edge |
+| `stickyStart`                | `"top" \| "bottom" \| "left" \| "right"` | -       | Which edge to stick to                 |
+| `viewportCulling`            | `boolean`                                | `true`  | Only render visible children           |
+| `scrollAcceleration`         | `ScrollAcceleration`                     | -       | Custom scroll acceleration algorithm   |
+| `rootOptions`                | `BoxOptions`                             | -       | Style options for root container       |
+| `wrapperOptions`             | `BoxOptions`                             | -       | Style options for wrapper              |
+| `viewportOptions`            | `BoxOptions`                             | -       | Style options for viewport             |
+| `contentOptions`             | `BoxOptions`                             | -       | Style options for content container    |
+| `scrollbarOptions`           | `ScrollBarOptions`                       | -       | Options for both scrollbars            |
+| `verticalScrollbarOptions`   | `ScrollBarOptions`                       | -       | Options for vertical scrollbar only    |
+| `horizontalScrollbarOptions` | `ScrollBarOptions`                       | -       | Options for horizontal scrollbar only  |
+
+## Additional properties
+
+| Property       | Type     | Description                                  |
+| -------------- | -------- | -------------------------------------------- |
+| `scrollTop`    | `number` | Current vertical scroll position (get/set)   |
+| `scrollLeft`   | `number` | Current horizontal scroll position (get/set) |
+| `scrollWidth`  | `number` | Total scrollable width (read-only)           |
+| `scrollHeight` | `number` | Total scrollable height (read-only)          |
+
+## Internal components
+
+ScrollBox exposes its internal components for advanced use:
+
+```typescript
+scrollbox.wrapper // BoxRenderable - outer wrapper
+scrollbox.viewport // BoxRenderable - visible area
+scrollbox.content // ContentRenderable - holds children
+scrollbox.horizontalScrollBar // ScrollBarRenderable
+scrollbox.verticalScrollBar // ScrollBarRenderable
+```
diff --git a/.agents/skills/opentui/docs/components/select.mdx b/.agents/skills/opentui/docs/components/select.mdx
new file mode 100644
index 0000000..00d51c8
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/select.mdx
@@ -0,0 +1,205 @@
+---
+title: Select
+description: List selection component for choosing from options
+order: 5
+---
+
+# Select
+
+A vertical list for choosing from multiple options. Focus the select to enable keyboard input.
+
+## Basic usage
+
+### Renderable API
+
+```typescript
+import { SelectRenderable, SelectRenderableEvents, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const menu = new SelectRenderable(renderer, {
+  id: "menu",
+  width: 30,
+  height: 8,
+  options: [
+    { name: "New File", description: "Create a new file" },
+    { name: "Open File", description: "Open an existing file" },
+    { name: "Save", description: "Save current file" },
+    { name: "Exit", description: "Exit the application" },
+  ],
+})
+
+menu.on(SelectRenderableEvents.ITEM_SELECTED, (index, option) => {
+  console.log("Selected:", option.name)
+})
+
+menu.focus()
+renderer.root.add(menu)
+```
+
+### Construct API
+
+```typescript
+import { Select, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const menu = Select({
+  width: 30,
+  height: 8,
+  options: [
+    { name: "Option 1", description: "First option" },
+    { name: "Option 2", description: "Second option" },
+    { name: "Option 3", description: "Third option" },
+  ],
+})
+
+menu.focus()
+renderer.root.add(menu)
+```
+
+## Keyboard navigation
+
+When focused, the select responds to these keys:
+
+| Key                       | Action                |
+| ------------------------- | --------------------- |
+| `Up` / `k`                | Move selection up     |
+| `Down` / `j`              | Move selection down   |
+| `Shift+Up` / `Shift+Down` | Fast scroll (5 items) |
+| `Enter`                   | Select current item   |
+
+## Events
+
+### Item selected
+
+Fires when the user presses Enter on an option:
+
+```typescript
+import { SelectRenderableEvents } from "@opentui/core"
+
+menu.on(SelectRenderableEvents.ITEM_SELECTED, (index: number, option: SelectOption) => {
+  console.log(`Selected index ${index}: ${option.name}`)
+})
+```
+
+### Selection changed
+
+Fires when the highlighted item changes:
+
+```typescript
+menu.on(SelectRenderableEvents.SELECTION_CHANGED, (index: number, option: SelectOption) => {
+  console.log(`Highlighted: ${option.name}`)
+  // Update a preview pane, for example
+})
+```
+
+## Option structure
+
+```typescript
+interface SelectOption {
+  name: string // Display text
+  description: string // Displays below the name when showDescription is true
+  value?: any // Optional value
+}
+```
+
+## Styling
+
+```typescript
+const styledMenu = new SelectRenderable(renderer, {
+  id: "styled-menu",
+  width: 40,
+  height: 10,
+  options: [...],
+  backgroundColor: "#1a1a1a",
+  selectedBackgroundColor: "#333366",
+  selectedTextColor: "#FFFFFF",
+  textColor: "#AAAAAA",
+  descriptionColor: "#666666",
+})
+```
+
+## Properties
+
+| Property                   | Type             | Default       | Description                       |
+| -------------------------- | ---------------- | ------------- | --------------------------------- |
+| `width`                    | `number`         | -             | Component width                   |
+| `height`                   | `number`         | -             | Component height                  |
+| `options`                  | `SelectOption[]` | `[]`          | Available options                 |
+| `selectedIndex`            | `number`         | `0`           | Initially selected index          |
+| `backgroundColor`          | `string \| RGBA` | `transparent` | Background color                  |
+| `textColor`                | `string \| RGBA` | `#FFFFFF`     | Normal text color                 |
+| `focusedBackgroundColor`   | `string \| RGBA` | `#1a1a1a`     | Background when focused           |
+| `focusedTextColor`         | `string \| RGBA` | `#FFFFFF`     | Text color when focused           |
+| `selectedBackgroundColor`  | `string \| RGBA` | `#334455`     | Selected item background          |
+| `selectedTextColor`        | `string \| RGBA` | `#FFFF00`     | Selected item text color          |
+| `descriptionColor`         | `string \| RGBA` | `#888888`     | Description text color            |
+| `selectedDescriptionColor` | `string \| RGBA` | `#CCCCCC`     | Selected item description color   |
+| `showDescription`          | `boolean`        | `true`        | Show option descriptions          |
+| `showScrollIndicator`      | `boolean`        | `false`       | Show scroll position indicator    |
+| `wrapSelection`            | `boolean`        | `false`       | Wrap selection at list boundaries |
+| `itemSpacing`              | `number`         | `0`           | Spacing between items             |
+| `fastScrollStep`           | `number`         | `5`           | Items to skip with Shift+Up/Down  |
+
+## Example: file menu
+
+```typescript
+import { Box, Select, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const fileMenu = Select({
+  width: 25,
+  height: 12,
+  options: [
+    { name: "New", description: "Create new file (Ctrl+N)" },
+    { name: "Open...", description: "Open file (Ctrl+O)" },
+    { name: "Save", description: "Save file (Ctrl+S)" },
+    { name: "Save As...", description: "Save with new name" },
+    { name: "---", description: "" }, // Separator (visual only)
+    { name: "Exit", description: "Quit application (Ctrl+Q)" },
+  ],
+})
+
+const menuPanel = Box(
+  {
+    borderStyle: "single",
+    borderColor: "#666",
+  },
+  fileMenu,
+)
+
+fileMenu.focus()
+renderer.root.add(menuPanel)
+```
+
+## Programmatic control
+
+```typescript
+// Get current selection index
+const currentIndex = menu.getSelectedIndex()
+
+// Get currently selected option
+const option = menu.getSelectedOption()
+
+// Set selection programmatically
+menu.setSelectedIndex(2)
+
+// Navigate programmatically
+menu.moveUp() // Move up one item
+menu.moveDown() // Move down one item
+menu.moveUp(3) // Move up multiple items
+menu.selectCurrent() // Trigger selection of current item
+
+// Update options dynamically
+menu.options = [
+  { name: "New Option 1", description: "First" },
+  { name: "New Option 2", description: "Second" },
+]
+
+// Toggle display options
+menu.showDescription = false
+menu.showScrollIndicator = true
+menu.wrapSelection = true
+```
diff --git a/.agents/skills/opentui/docs/components/slider.mdx b/.agents/skills/opentui/docs/components/slider.mdx
new file mode 100644
index 0000000..4feda72
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/slider.mdx
@@ -0,0 +1,64 @@
+---
+title: Slider
+description: A draggable slider for continuous values
+order: 9
+---
+
+# Slider
+
+A draggable slider for continuous values. Supports vertical and horizontal orientations.
+
+## Basic usage
+
+### Renderable API
+
+```typescript
+import { SliderRenderable, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const slider = new SliderRenderable(renderer, {
+  id: "volume",
+  orientation: "horizontal",
+  width: 30,
+  height: 1,
+  min: 0,
+  max: 100,
+  value: 25,
+  onChange: (value) => {
+    console.log("Value:", value)
+  },
+})
+
+renderer.root.add(slider)
+```
+
+## Vertical slider
+
+```typescript
+const slider = new SliderRenderable(renderer, {
+  orientation: "vertical",
+  width: 2,
+  height: 10,
+  min: 0,
+  max: 1,
+  value: 0.5,
+})
+```
+
+## Construct API
+
+> Not available yet. Use `SliderRenderable` for now.
+
+## Properties
+
+| Property          | Type                           | Default      | Description                    |
+| ----------------- | ------------------------------ | ------------ | ------------------------------ |
+| `orientation`     | `"vertical"` or `"horizontal"` | -            | Slider direction               |
+| `value`           | `number`                       | `min`        | Current value                  |
+| `min`             | `number`                       | `0`          | Minimum value                  |
+| `max`             | `number`                       | `100`        | Maximum value                  |
+| `viewPortSize`    | `number`                       | range \* 0.1 | Thumb size relative to content |
+| `backgroundColor` | `string` or `RGBA`             | -            | Track color                    |
+| `foregroundColor` | `string` or `RGBA`             | -            | Thumb color                    |
+| `onChange`        | `(value: number) => void`      | -            | Fired when value changes       |
diff --git a/.agents/skills/opentui/docs/components/tab-select.mdx b/.agents/skills/opentui/docs/components/tab-select.mdx
new file mode 100644
index 0000000..c0eb9ef
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/tab-select.mdx
@@ -0,0 +1,203 @@
+---
+title: TabSelect
+description: Horizontal tab-based selection component
+order: 6
+---
+
+# TabSelect
+
+Horizontal tab-based selection component with descriptions and scroll support. The component must be focused to receive keyboard input.
+
+## Basic Usage
+
+### Renderable API
+
+```typescript
+import { TabSelectRenderable, TabSelectRenderableEvents, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const tabs = new TabSelectRenderable(renderer, {
+  id: "tabs",
+  width: 60,
+  options: [
+    { name: "Home", description: "Dashboard and overview" },
+    { name: "Files", description: "File management" },
+    { name: "Settings", description: "Application settings" },
+  ],
+  tabWidth: 20,
+})
+
+tabs.on(TabSelectRenderableEvents.ITEM_SELECTED, (index, option) => {
+  console.log("Tab selected:", option.name)
+})
+
+tabs.focus()
+renderer.root.add(tabs)
+```
+
+### Construct API
+
+```typescript
+import { TabSelect, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const tabs = TabSelect({
+  width: 60,
+  tabWidth: 15,
+  options: [
+    { name: "Tab 1", description: "First tab" },
+    { name: "Tab 2", description: "Second tab" },
+    { name: "Tab 3", description: "Third tab" },
+  ],
+})
+
+tabs.focus()
+renderer.root.add(tabs)
+```
+
+## Keyboard Navigation
+
+When focused, the tab select responds to these keys:
+
+| Key           | Action               |
+| ------------- | -------------------- |
+| `Left` / `[`  | Move to previous tab |
+| `Right` / `]` | Move to next tab     |
+| `Enter`       | Select current tab   |
+
+## Events
+
+### Item Selected
+
+Emitted when the user presses Enter on a tab:
+
+```typescript
+import { TabSelectRenderableEvents, type TabSelectOption } from "@opentui/core"
+
+tabs.on(TabSelectRenderableEvents.ITEM_SELECTED, (index: number, option: TabSelectOption) => {
+  console.log(`Selected tab ${index}: ${option.name}`)
+  // Switch to the corresponding panel
+})
+```
+
+### Selection Changed
+
+Emitted when the highlighted tab changes:
+
+```typescript
+import { TabSelectRenderableEvents, type TabSelectOption } from "@opentui/core"
+
+tabs.on(TabSelectRenderableEvents.SELECTION_CHANGED, (index: number, option: TabSelectOption) => {
+  console.log(`Hovering: ${option.name}`)
+})
+```
+
+## Properties
+
+| Property                   | Type                    | Default       | Description                    |
+| -------------------------- | ----------------------- | ------------- | ------------------------------ |
+| `width`                    | `number`                | -             | Total component width          |
+| `options`                  | `TabSelectOption[]`     | `[]`          | Available tabs                 |
+| `tabWidth`                 | `number`                | `20`          | Width of each tab              |
+| `backgroundColor`          | `string \| RGBA`        | `transparent` | Background color               |
+| `textColor`                | `string \| RGBA`        | `#FFFFFF`     | Normal tab text                |
+| `focusedBackgroundColor`   | `string \| RGBA`        | `#1a1a1a`     | Background color when focused  |
+| `focusedTextColor`         | `string \| RGBA`        | `#FFFFFF`     | Text color when focused        |
+| `selectedBackgroundColor`  | `string \| RGBA`        | `#334455`     | Selected tab background        |
+| `selectedTextColor`        | `string \| RGBA`        | `#FFFF00`     | Selected tab text              |
+| `selectedDescriptionColor` | `string \| RGBA`        | `#CCCCCC`     | Description text color         |
+| `showScrollArrows`         | `boolean`               | `true`        | Show scroll indicators         |
+| `showDescription`          | `boolean`               | `true`        | Show tab descriptions          |
+| `showUnderline`            | `boolean`               | `true`        | Show underline on selected tab |
+| `wrapSelection`            | `boolean`               | `false`       | Wrap around when navigating    |
+| `keyBindings`              | `TabSelectKeyBinding[]` | -             | Custom key bindings            |
+| `keyAliasMap`              | `KeyAliasMap`           | -             | Key alias mappings             |
+
+## Example: Tabbed Interface
+
+```typescript
+import { Box, Text, TabSelect, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+// Create content panels
+const panels = {
+  home: Box({ padding: 1 }, Text({ content: "Home content here" })),
+  files: Box({ padding: 1 }, Text({ content: "File browser here" })),
+  settings: Box({ padding: 1 }, Text({ content: "Settings form here" })),
+}
+
+// Create the tabbed container
+const container = Box({
+  width: 60,
+  height: 20,
+  borderStyle: "rounded",
+})
+
+const tabs = TabSelect({
+  width: 60,
+  tabWidth: 20,
+  options: [
+    { name: "Home", description: "Dashboard" },
+    { name: "Files", description: "Browse files" },
+    { name: "Settings", description: "Preferences" },
+  ],
+})
+
+// Content area
+let currentPanel = panels.home
+const contentArea = Box({
+  flexGrow: 1,
+  padding: 1,
+})
+contentArea.add(currentPanel)
+
+// Handle tab changes
+tabs.on("itemSelected", (index, option) => {
+  // Remove current panel
+  if (currentPanel) {
+    contentArea.remove(currentPanel.id)
+  }
+  // Add new panel based on selection
+  switch (option.name) {
+    case "Home":
+      currentPanel = panels.home
+      break
+    case "Files":
+      currentPanel = panels.files
+      break
+    case "Settings":
+      currentPanel = panels.settings
+      break
+  }
+  contentArea.add(currentPanel)
+})
+
+container.add(tabs)
+container.add(contentArea)
+
+tabs.focus()
+renderer.root.add(container)
+```
+
+## Programmatic Control
+
+```typescript
+// Get current tab index
+const currentIndex = tabs.getSelectedIndex()
+
+// Set tab programmatically
+tabs.setSelectedIndex(1)
+
+// Update tabs dynamically
+tabs.setOptions([
+  { name: "New Tab 1", description: "Updated" },
+  { name: "New Tab 2", description: "Also updated" },
+])
+```
+
+## Scroll Behavior
+
+When there are more tabs than fit in the width, the component automatically handles horizontal scrolling as you navigate with the keyboard.
diff --git a/.agents/skills/opentui/docs/components/text.mdx b/.agents/skills/opentui/docs/components/text.mdx
new file mode 100644
index 0000000..c44d8b2
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/text.mdx
@@ -0,0 +1,175 @@
+---
+title: Text
+description: Display styled text content
+order: 1
+skill:
+  entry: true
+  intents: [text, styling, content, selection]
+---
+
+# Text
+
+Display styled text content with support for colors, attributes, and text selection.
+
+## Basic Usage
+
+### Renderable API
+
+```typescript
+import { TextRenderable, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const text = new TextRenderable(renderer, {
+  id: "greeting",
+  content: "Hello, OpenTUI!",
+  fg: "#00FF00",
+})
+
+renderer.root.add(text)
+```
+
+### Construct API
+
+```typescript
+import { Text, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+renderer.root.add(
+  Text({
+    content: "Hello, OpenTUI!",
+    fg: "#00FF00",
+  }),
+)
+```
+
+## Text attributes
+
+Combine multiple text attributes using bitwise OR:
+
+```typescript
+import { TextRenderable, TextAttributes } from "@opentui/core"
+
+const styledText = new TextRenderable(renderer, {
+  id: "styled",
+  content: "Important Message",
+  fg: "#FFFF00",
+  attributes: TextAttributes.BOLD | TextAttributes.UNDERLINE,
+})
+```
+
+### Available attributes
+
+| Attribute                      | Description        |
+| ------------------------------ | ------------------ |
+| `TextAttributes.BOLD`          | Bold text          |
+| `TextAttributes.DIM`           | Dimmed text        |
+| `TextAttributes.ITALIC`        | Italic text        |
+| `TextAttributes.UNDERLINE`     | Underlined text    |
+| `TextAttributes.BLINK`         | Blinking text      |
+| `TextAttributes.INVERSE`       | Inverted colors    |
+| `TextAttributes.HIDDEN`        | Hidden text        |
+| `TextAttributes.STRIKETHROUGH` | Strikethrough text |
+
+## Template literals for rich text
+
+Use the `t` template literal for inline styling within a single text element:
+
+```typescript
+import { TextRenderable, t, bold, underline, fg, bg, italic } from "@opentui/core"
+
+const richText = new TextRenderable(renderer, {
+  id: "rich",
+  content: t`${bold("Important:")} ${fg("#FF0000")(underline("Warning!"))} Normal text`,
+})
+```
+
+### Available style functions
+
+```typescript
+import { t, bold, dim, italic, underline, blink, reverse, strikethrough, fg, bg } from "@opentui/core"
+
+// Basic attributes
+t`${bold("bold text")}`
+t`${italic("italic text")}`
+t`${underline("underlined")}`
+t`${strikethrough("deleted")}`
+
+// Colors
+t`${fg("#FF0000")("red text")}`
+t`${bg("#0000FF")("blue background")}`
+
+// Combining styles
+t`${bold(fg("#FFFF00")("bold yellow"))}`
+```
+
+## Positioning
+
+```typescript
+const text = new TextRenderable(renderer, {
+  id: "positioned",
+  content: "Absolute position",
+  position: "absolute",
+  left: 10,
+  top: 5,
+})
+```
+
+## Text selection
+
+Enable text selection for copying:
+
+```typescript
+const selectableText = new TextRenderable(renderer, {
+  id: "selectable",
+  content: "Select me!",
+  selectable: true, // Default is true
+})
+
+const nonSelectable = new TextRenderable(renderer, {
+  id: "label",
+  content: "Button Label",
+  selectable: false, // Disable selection
+})
+```
+
+## Properties
+
+| Property                         | Type                              | Default      | Description                  |
+| -------------------------------- | --------------------------------- | ------------ | ---------------------------- |
+| `content`                        | `string \| StyledText`            | `""`         | The text content to display  |
+| `fg`                             | `string \| RGBA`                  | -            | Foreground (text) color      |
+| `bg`                             | `string \| RGBA`                  | -            | Background color             |
+| `attributes`                     | `TextAttributes`                  | `0`          | Text styling attributes      |
+| `selectable`                     | `boolean`                         | `true`       | Whether text can be selected |
+| `position`                       | `"relative" \| "absolute"`        | `"relative"` | Positioning mode             |
+| `left`, `top`, `right`, `bottom` | `number \| "auto" \| "{number}%"` | -            | Position offsets             |
+
+## Example: status bar
+
+```typescript
+import { Text, Box, t, bold, fg } from "@opentui/core"
+
+const statusBar = Box(
+  {
+    position: "absolute",
+    bottom: 0,
+    width: "100%",
+    height: 1,
+    backgroundColor: "#333333",
+    flexDirection: "row",
+    justifyContent: "space-between",
+    paddingLeft: 1,
+    paddingRight: 1,
+  },
+  Text({
+    content: t`${bold("myfile.ts")} - ${fg("#888888")("TypeScript")}`,
+  }),
+  Text({
+    content: t`Ln ${fg("#00FF00")("42")}, Col ${fg("#00FF00")("15")}`,
+  }),
+)
+
+renderer.root.add(statusBar)
+```
diff --git a/.agents/skills/opentui/docs/components/textarea.mdx b/.agents/skills/opentui/docs/components/textarea.mdx
new file mode 100644
index 0000000..f503a85
--- /dev/null
+++ b/.agents/skills/opentui/docs/components/textarea.mdx
@@ -0,0 +1,182 @@
+---
+title: Textarea
+description: Multi-line text input with selection and keybindings
+order: 4
+---
+
+# Textarea
+
+Multi-line text input with cursor, selection, and rich keybindings.
+
+## Basic usage
+
+### Renderable API
+
+```typescript
+import { TextareaRenderable, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const textarea = new TextareaRenderable(renderer, {
+  id: "notes",
+  width: 50,
+  height: 6,
+  placeholder: "Type notes here...",
+  backgroundColor: "#1a1a1a",
+  focusedBackgroundColor: "#222222",
+  textColor: "#FFFFFF",
+  cursorColor: "#00FF88",
+})
+
+renderer.root.add(textarea)
+textarea.focus()
+```
+
+## Submit handling
+
+Bind a submit action and listen for `onSubmit`:
+
+```typescript
+import { TextareaRenderable } from "@opentui/core"
+
+const textarea = new TextareaRenderable(renderer, {
+  width: 50,
+  height: 6,
+  onSubmit: () => {
+    console.log("Submitted:", textarea.plainText)
+  },
+  keyBindings: [{ name: "return", ctrl: true, action: "submit" }],
+})
+```
+
+## Placeholder styling
+
+```typescript
+const textarea = new TextareaRenderable(renderer, {
+  width: 40,
+  height: 4,
+  placeholder: "Type here",
+  placeholderColor: "#666666",
+})
+```
+
+## Construct API
+
+> Not available yet. Use `TextareaRenderable` for now.
+
+## Properties
+
+| Property                 | Type                                  | Default     | Description                       |
+| ------------------------ | ------------------------------------- | ----------- | --------------------------------- |
+| `width`                  | `number` or `string`                  | -           | Width in characters or percentage |
+| `height`                 | `number` or `string`                  | -           | Height in rows or percentage      |
+| `initialValue`           | `string`                              | `""`        | Initial text content              |
+| `placeholder`            | `string`, `StyledText`, or `null`     | `null`      | Placeholder content               |
+| `placeholderColor`       | `string` or `RGBA`                    | `#666666`   | Placeholder color                 |
+| `backgroundColor`        | `string` or `RGBA`                    | transparent | Background when unfocused         |
+| `textColor`              | `string` or `RGBA`                    | `#FFFFFF`   | Text color when unfocused         |
+| `focusedBackgroundColor` | `string` or `RGBA`                    | transparent | Background when focused           |
+| `focusedTextColor`       | `string` or `RGBA`                    | `#FFFFFF`   | Text color when focused           |
+| `wrapMode`               | `"none"`, `"char"`, or `"word"`       | `"word"`    | Line wrapping mode                |
+| `selectionBg`            | `string` or `RGBA`                    | -           | Selection background              |
+| `selectionFg`            | `string` or `RGBA`                    | -           | Selection foreground              |
+| `cursorColor`            | `string` or `RGBA`                    | `#FFFFFF`   | Cursor color                      |
+| `cursorStyle`            | `CursorStyleOptions`                  | -           | Cursor style and blinking         |
+| `keyBindings`            | `KeyBinding[]`                        | -           | Custom keybindings                |
+| `keyAliasMap`            | `KeyAliasMap`                         | -           | Key alias mapping                 |
+| `onSubmit`               | `(event: SubmitEvent) => void`        | -           | Submit handler                    |
+| `onContentChange`        | `(event: ContentChangeEvent) => void` | -           | Fired on content changes          |
+| `onCursorChange`         | `(event: CursorChangeEvent) => void`  | -           | Fired on cursor movement          |
+
+## Useful properties
+
+| Property                | Type                       | Description                                                     |
+| ----------------------- | -------------------------- | --------------------------------------------------------------- |
+| `plainText`             | `string`                   | Current text content                                            |
+| `cursorOffset`          | `number`                   | Cursor offset in the buffer                                     |
+| `cursorCharacterOffset` | `number \| undefined`      | Offset of the character under the cursor (skips trailing blank) |
+| `logicalCursor`         | `{ row, col }`             | Logical line/column of the cursor                               |
+| `visualCursor`          | `{ row, col, visualLine }` | Visual (post-wrap) cursor position                              |
+| `traits`                | `EditorTraits`             | Editor traits published to hosting UI (see [Traits](#traits))   |
+
+## Cursor and selection control
+
+`TextareaRenderable` (and its base `EditBufferRenderable`) exposes a programmatic API. You can move the cursor, edit text, and drive selections from your own keybindings or commands. All selection-aware movement methods accept `{ select: true }` to extend the current selection instead of moving the cursor.
+
+### Cursor movement
+
+```typescript
+textarea.setCursor(row, col)
+textarea.moveCursorLeft()
+textarea.moveCursorRight({ select: true })
+textarea.moveCursorUp()
+textarea.moveCursorDown()
+
+textarea.moveWordForward({ select: true })
+textarea.moveWordBackward()
+
+textarea.gotoLine(0)
+textarea.gotoLineStart()
+textarea.gotoLineTextEnd()
+textarea.gotoLineHome({ select: true }) // Emacs-style smart home
+textarea.gotoLineEnd()
+textarea.gotoVisualLineHome()
+textarea.gotoVisualLineEnd()
+textarea.gotoBufferHome()
+textarea.gotoBufferEnd({ select: true })
+```
+
+### Selection
+
+```typescript
+textarea.setSelection(start, end) // half-open offsets
+textarea.setSelectionInclusive(start, end) // inclusive end
+textarea.selectAll()
+textarea.clearSelection()
+textarea.deleteSelection()
+```
+
+### Editing
+
+```typescript
+textarea.insertChar("a")
+textarea.insertText("\ninserted")
+textarea.deleteChar() // forward delete
+textarea.deleteCharBackward() // backspace
+textarea.deleteWordForward()
+textarea.deleteWordBackward()
+textarea.deleteToLineEnd()
+textarea.deleteToLineStart()
+textarea.deleteLine()
+textarea.newLine()
+textarea.undo()
+textarea.redo()
+```
+
+These methods update the cursor, clear any active global selection, and call `requestRender()` for you.
+
+## Traits
+
+The `traits` property lets an editor advertise intent to a host UI — which built-in keys it wants to capture, whether it wants the chrome to visually suspend, and a short status label for a footer or status bar. Assigning a new `EditorTraits` object emits the `traits-changed` event when the value differs from the previous one.
+
+```typescript
+import { EditBufferRenderableEvents, type EditorTraits } from "@opentui/core"
+
+textarea.traits = {
+  capture: ["escape", "submit"], // consume these before host binds
+  suspend: false,
+  status: "Composing reply",
+} satisfies EditorTraits
+
+textarea.on(EditBufferRenderableEvents.TRAITS_CHANGED, (traits) => {
+  updateFooter(traits.status ?? "")
+})
+```
+
+| Field     | Type              | Description                                                                     |
+| --------- | ----------------- | ------------------------------------------------------------------------------- |
+| `capture` | `EditorCapture[]` | Keys the editor wants to capture: `"escape"`, `"navigate"`, `"submit"`, `"tab"` |
+| `suspend` | `boolean`         | Hint to the host to suspend ambient UI (dim borders, hide hints, etc.)          |
+| `status`  | `string`          | Optional short label surfacing editor mode in a status bar                      |
+
+Traits reset to an empty object when you destroy the renderable. Use `isEditBufferRenderable(renderable)` if you need to distinguish editor renderables from plain text renderables in a generic tree.
diff --git a/.agents/skills/opentui/docs/core-concepts/audio.mdx b/.agents/skills/opentui/docs/core-concepts/audio.mdx
new file mode 100644
index 0000000..34cdf9a
--- /dev/null
+++ b/.agents/skills/opentui/docs/core-concepts/audio.mdx
@@ -0,0 +1,132 @@
+---
+title: Native audio
+description: Load, play, mix, and inspect audio with the native miniaudio backend
+order: 11
+skill:
+  entry: true
+  intents: [audio, native-audio, sound, playback, pcm, fft]
+---
+
+# Native audio
+
+OpenTUI exposes a native miniaudio-backed `Audio` engine from `@opentui/core`. It can decode audio bytes or files, play sounds through named groups, choose playback devices, mix into PCM buffers, and expose recent mixed frames for visualization.
+
+## Basic usage
+
+```typescript
+import { Audio } from "@opentui/core"
+
+const audio = Audio.create({ autoStart: false })
+
+audio.on("error", (error, context) => {
+  console.error(`${context.action}: ${error.message}`)
+})
+
+const sound = await audio.loadSoundFile("click.wav")
+if (sound != null && audio.start()) {
+  audio.play(sound, { volume: 0.8, pan: 0, loop: false })
+}
+
+audio.dispose()
+```
+
+Use `setupAudio(options?)` when you prefer a function wrapper around `Audio.create(options?)`.
+
+## Engine options
+
+| Option             | Default  | Description                                    |
+| ------------------ | -------- | ---------------------------------------------- |
+| `autoStart`        | `false`  | Call `start()` during creation                 |
+| `sampleRate`       | `48000`  | Engine sample rate                             |
+| `playbackChannels` | `2`      | Requested playback channel count               |
+| `startOptions`     | defaults | Options passed to `start()` when auto-starting |
+
+Create a new `Audio` instance to change `sampleRate` or `playbackChannels`.
+
+## Sounds and voices
+
+| Method                          | Description                                                   |
+| ------------------------------- | ------------------------------------------------------------- |
+| `loadSound(data)`               | Decode `Uint8Array` or `ArrayBuffer`; returns `AudioSound`    |
+| `loadSoundFile(path)`           | Read and decode a file; returns `Promise<AudioSound \| null>` |
+| `unloadSound(sound)`            | Free a loaded sound and stop voices using it                  |
+| `play(sound, options?)`         | Start a voice; returns `AudioVoice \| null`                   |
+| `stopVoice(voice)`              | Stop one active voice                                         |
+| `group(name)`                   | Create or reuse a named group; group `0` is the default group |
+| `setVoiceGroup(voice, group)`   | Move a voice to another group                                 |
+| `setGroupVolume(group, volume)` | Set group volume                                              |
+| `setMasterVolume(volume)`       | Set master volume                                             |
+
+`play()` accepts `{ volume, pan, loop, groupId }`. Native playback clamps `volume` to `0..4` and `pan` to `-1..1`. The engine has 32 voice slots.
+
+## Starting audio
+
+`start()` starts native playback and returns `false` when no output device is available. Use `isStarted()` to check native playback state.
+
+For headless mixing, tests, benchmarks, or manual `mixFrames()` output, use `startMixer()`. It starts the mixer without opening a playback device. Use `isMixerStarted()` to check either mode.
+
+## Bun standalone executables
+
+Bun embeds files in `bun build --compile` executables when they are imported with `with { type: "file" }`. Read the embedded file as bytes and pass it to `loadSound()` so audio decodes from memory instead of a file path.
+
+```typescript
+import { file } from "bun"
+import { Audio } from "@opentui/core"
+import clickPath from "./click.wav" with { type: "file" }
+
+const audio = Audio.create({ autoStart: false })
+const clickBytes = await file(clickPath).bytes()
+const click = audio.loadSound(clickBytes)
+
+if (click != null && audio.start()) {
+  audio.play(click)
+}
+```
+
+Compile the app normally with `bun build --compile ./app.ts --outfile app`.
+
+## Node.js standalone executables
+
+Coming soon.
+
+## Devices
+
+Select devices before starting the engine:
+
+```typescript
+const audio = Audio.create({ autoStart: false })
+const devices = audio.listPlaybackDevices() ?? []
+const device = devices.find((item) => item.isDefault) ?? devices[0]
+
+if (device) {
+  audio.selectPlaybackDevice(device.index)
+}
+
+if (!audio.start()) {
+  console.error("No playback device available")
+}
+```
+
+`listPlaybackDevices()` returns `{ index, name, isDefault }[] | null`. Use `clearPlaybackDeviceSelection()` to return to the default device selection.
+
+## Mixing and analysis
+
+| Method                                  | Description                                                                                |
+| --------------------------------------- | ------------------------------------------------------------------------------------------ |
+| `mixFrames(frameCount, channels=2)`     | Mix into a `Float32Array`; mono downmixes, channels above stereo keep extras zero          |
+| `getStats()`                            | Returns `soundsLoaded`, `voicesActive`, `framesMixed`, `lockMisses`, `lastPeak`, `lastRms` |
+| `enableTap(capacityFrames=8192)`        | Enable a fixed-size native ring buffer of recent mixed frames                              |
+| `readTapFrames(frameCount, channels=2)` | Copy the latest tapped frames; returns `{ frames, framesRead }`                            |
+| `disableTap()`                          | Free the tap buffer                                                                        |
+
+The tap is disabled by default. When enabled, it stores the latest frames and overwrites old data; reads do not drain it. OpenTUI does not compute FFT natively. For spectrum visualization, read tap frames and run FFT in TypeScript.
+
+## Start options
+
+`start(options?)` accepts low-level device options: `periodSizeInFrames`, `periodSizeInMilliseconds`, `periods`, `performanceProfile`, `shareMode`, `noPreSilencedOutputBuffer`, `noClip`, `noDisableDenormals`, `noFixedSizedCallback`, `wasapiNoAutoConvertSrc`, `wasapiNoDefaultQualitySrc`, `alsaNoMMap`, `alsaNoAutoFormat`, `alsaNoAutoChannels`, and `alsaNoAutoResample`.
+
+`performanceProfile` uses `0` for low latency and `1` for conservative. `shareMode` uses `0` for shared and `1` for exclusive.
+
+## Lifecycle and errors
+
+Use `start()`, `startMixer()`, `stop()`, `isStarted()`, `isMixerStarted()`, and `dispose()` for lifecycle. `Audio` emits `started`, `mixerStarted`, `stopped`, `disposed`, and `error`. Methods that fail return `false` or `null` and emit `error` with `{ action, status }` context.
diff --git a/.agents/skills/opentui/docs/core-concepts/colors.mdx b/.agents/skills/opentui/docs/core-concepts/colors.mdx
new file mode 100644
index 0000000..0173f7e
--- /dev/null
+++ b/.agents/skills/opentui/docs/core-concepts/colors.mdx
@@ -0,0 +1,226 @@
+---
+title: Colors
+description: Working with RGBA colors and palette-aware color intent in OpenTUI
+order: 9
+---
+
+# Colors
+
+OpenTUI uses the `RGBA` class for color representation. The class stores 8-bit RGBA channel values plus packed metadata internally, but provides methods for working with different color formats.
+
+Every color also carries **color intent** inside the packed value: an RGB snapshot, an indexed ANSI slot, or the terminal default. The renderer uses this intent to keep palette-relative colors stable when the terminal palette changes.
+
+## Creating colors
+
+### From integers (0-255)
+
+```typescript
+import { RGBA } from "@opentui/core"
+
+const red = RGBA.fromInts(255, 0, 0, 255)
+const semiTransparentBlue = RGBA.fromInts(0, 0, 255, 128)
+```
+
+### From float values (0.0-1.0)
+
+Float values are quantized to 8-bit channels for terminal output.
+
+```typescript
+const green = RGBA.fromValues(0.0, 1.0, 0.0, 1.0)
+const transparent = RGBA.fromValues(1.0, 1.0, 1.0, 0.5)
+```
+
+### From hex strings
+
+```typescript
+const purple = RGBA.fromHex("#800080")
+const withAlpha = RGBA.fromHex("#FF000080") // Semi-transparent red
+```
+
+## String colors
+
+Most component properties accept both `RGBA` objects and color strings:
+
+```typescript
+import { Text, Box } from "@opentui/core"
+
+// Using hex strings
+Text({ content: "Hello", fg: "#00FF00" })
+
+// Using CSS color names
+Box({ backgroundColor: "red", borderColor: "white" })
+
+// Using RGBA objects
+const customColor = RGBA.fromInts(100, 150, 200, 255)
+Text({ content: "Custom", fg: customColor })
+
+// Transparent
+Box({ backgroundColor: "transparent" })
+```
+
+## The parseColor utility
+
+The `parseColor()` function converts various color formats to RGBA:
+
+```typescript
+import { parseColor } from "@opentui/core"
+
+const color1 = parseColor("#FF0000") // Hex
+const color2 = parseColor("blue") // CSS color name
+const color3 = parseColor("transparent") // Transparent
+const color4 = parseColor(RGBA.fromInts(255, 0, 0, 255)) // Pass-through
+```
+
+## Color intent
+
+Every `RGBA` value stores intent in packed metadata next to the RGBA snapshot. The renderer reads this intent to decide which ANSI sequence to emit:
+
+- `rgb`: a literal RGB color. The renderer emits `38;2;r;g;b` / `48;2;r;g;b`.
+- `default`: the terminal's default foreground or background. The renderer emits `39` / `49` (SGR default) so the terminal picks the right side of its palette.
+- `indexed`: an indexed ANSI color. The renderer emits `38;5;n` / `48;5;n` so the user's theme overrides for that palette slot keep working when the palette changes.
+
+Each color still carries its RGBA values so alpha blending and non-ANSI renderers work. The intent flows end-to-end through TypeScript, the FFI, the buffer, and the native renderer.
+
+### Default foreground and background
+
+```typescript
+import { RGBA } from "@opentui/core"
+
+// Will emit SGR 39 / 49 when rendered
+const fg = RGBA.defaultForeground()
+const bg = RGBA.defaultBackground()
+```
+
+You can pass an optional snapshot color to override the RGBA fallback. The renderer uses the snapshot for early frames, before it detects the terminal palette:
+
+```typescript
+const fg = RGBA.defaultForeground("#E6EDF3")
+```
+
+### Indexed ANSI colors (0-255)
+
+```typescript
+import { RGBA, ansi256IndexToRgb } from "@opentui/core"
+
+// Indexed colors keep their palette slot even if the user changes their theme
+const ansiRed = RGBA.fromIndex(1)
+const ansiBrightBlue = RGBA.fromIndex(12)
+
+// With a custom RGBA snapshot (for early frames before palette detection)
+const themed = RGBA.fromIndex(4, "#1F6FEB")
+
+// Convert an ANSI 256 index to an RGB triplet
+const [r, g, b] = ansi256IndexToRgb(196)
+```
+
+### Inspecting color intent
+
+```typescript
+import { RGBA } from "@opentui/core"
+
+const fg = RGBA.defaultForeground()
+fg.intent // => "default"
+
+const indexed = RGBA.fromIndex(10)
+indexed.intent // => "indexed"
+indexed.slot // => 10
+
+const literal = RGBA.fromHex("#00FF00")
+literal.intent // => "rgb"
+```
+
+### Exported color constants and types
+
+| Export                     | Description                                           |
+| -------------------------- | ----------------------------------------------------- |
+| `DEFAULT_FOREGROUND_RGB`   | `[255, 255, 255]` fallback RGB triplet for default fg |
+| `DEFAULT_BACKGROUND_RGB`   | `[0, 0, 0]` fallback RGB triplet for default bg       |
+| `ColorIntent`              | `"rgb" \| "indexed" \| "default"`                     |
+| `RGBTriplet`               | `readonly [number, number, number]`                   |
+| `ansi256IndexToRgb(index)` | Converts an ANSI 256 palette index to an RGB triplet  |
+| `parseColor(value)`        | Parses `string \| RGBA` into an `RGBA` value          |
+
+## Packed transport
+
+`RGBA.buffer` is a `Uint16Array(4)`. The low byte of each component stores `r`, `g`, `b`, and `a`; the high bytes together store 32 bits of metadata.
+
+```typescript
+const color = RGBA.fromIndex(6)
+
+color.buffer // Uint16Array(4)
+color.intent // "indexed"
+color.slot // 6
+```
+
+This lets native buffers compare current and next frame colors with exact integer equality. It also keeps palette intent attached to the color as it crosses the TypeScript/native boundary.
+
+## Terminal palette detection
+
+When the terminal supports it, the renderer queries the active palette (OSC 4 for palette slots, OSC 10/11 for default fg/bg, plus other special colors where supported). Indexed colors stay mapped to the terminal's user-configured slots, default colors stay linked to the terminal defaults, and non-truecolor renderers can re-resolve RGB fallbacks against the detected palette.
+
+```typescript
+const colors = await renderer.getPalette({ size: 256 })
+
+console.log(colors.palette[1]) // '#cc0000' or whatever red your theme uses
+console.log(colors.defaultForeground, colors.defaultBackground)
+```
+
+Useful members:
+
+- `renderer.getPalette(options?)` — returns a `TerminalColors` snapshot. Cached by requested size (`16` or `256`).
+- `renderer.paletteDetectionStatus` — `"idle" | "detecting" | "cached"`.
+- `renderer.clearPaletteCache()` — drop cached palettes (for example, after the user changes their theme).
+- `renderer.on("palette", handler)` — subscribe to refreshed palette snapshots when the detected palette changes.
+
+`getPalette` throws if the renderer is suspended. Startup palette detection runs automatically only when native ANSI-256 fallback rendering needs palette data (`ansi256` without truecolor `rgb`). Truecolor terminals query the palette only when you call `getPalette()` or when a palette listener exists and the terminal reports a theme change.
+
+## Alpha blending
+
+You can use transparent cells and alpha blending for layered effects:
+
+```typescript
+import { FrameBufferRenderable, RGBA } from "@opentui/core"
+
+const canvas = new FrameBufferRenderable(renderer, {
+  id: "canvas",
+  width: 50,
+  height: 20,
+})
+
+// Draw with alpha blending
+const semiTransparent = RGBA.fromValues(1.0, 0.0, 0.0, 0.5)
+const transparent = RGBA.fromInts(0, 0, 0, 0)
+canvas.frameBuffer.setCellWithAlphaBlending(10, 5, " ", transparent, semiTransparent)
+```
+
+Blended colors become literal RGB colors internally. This is intentional: once colors are blended, the result no longer represents a specific ANSI slot or terminal default.
+
+## Text attributes with colors
+
+Combine colors with text attributes:
+
+```typescript
+import { TextRenderable, TextAttributes, RGBA } from "@opentui/core"
+
+const styledText = new TextRenderable(renderer, {
+  id: "styled",
+  content: "Important",
+  fg: RGBA.fromHex("#FFFF00"),
+  bg: RGBA.fromHex("#333333"),
+  attributes: TextAttributes.BOLD | TextAttributes.UNDERLINE,
+})
+```
+
+## Color constants
+
+Common colors:
+
+```typescript
+// Some examples of commonly used colors
+const white = RGBA.fromInts(255, 255, 255, 255)
+const black = RGBA.fromInts(0, 0, 0, 255)
+const red = RGBA.fromInts(255, 0, 0, 255)
+const green = RGBA.fromInts(0, 255, 0, 255)
+const blue = RGBA.fromInts(0, 0, 255, 255)
+const transparent = RGBA.fromInts(0, 0, 0, 0)
+```
diff --git a/.agents/skills/opentui/docs/core-concepts/console.mdx b/.agents/skills/opentui/docs/core-concepts/console.mdx
new file mode 100644
index 0000000..7463a03
--- /dev/null
+++ b/.agents/skills/opentui/docs/core-concepts/console.mdx
@@ -0,0 +1,117 @@
+---
+title: Console overlay
+description: Built-in debugging console for TUI applications
+order: 7
+---
+
+# Console overlay
+
+OpenTUI includes a built-in console overlay that captures all `console.log`, `console.info`, `console.warn`, `console.error`, and `console.debug` calls. You can position the console at any edge of the terminal. It supports scrolling and focus management.
+
+## Basic usage
+
+```typescript
+import { createCliRenderer, ConsolePosition } from "@opentui/core"
+
+const renderer = await createCliRenderer({
+  consoleOptions: {
+    position: ConsolePosition.BOTTOM,
+    sizePercent: 30,
+  },
+})
+
+// These appear in the overlay instead of stdout
+console.log("This appears in the overlay")
+console.error("Errors are color-coded red")
+console.warn("Warnings appear in yellow")
+```
+
+## Configuration options
+
+```typescript
+const renderer = await createCliRenderer({
+  consoleOptions: {
+    position: ConsolePosition.BOTTOM, // Position on screen
+    sizePercent: 30, // Size as percentage of terminal
+    colorInfo: "#00FFFF", // Color for console.info
+    colorWarn: "#FFFF00", // Color for console.warn
+    colorError: "#FF0000", // Color for console.error
+    startInDebugMode: false, // Show file/line info in logs
+  },
+})
+```
+
+## Console positions
+
+```typescript
+import { ConsolePosition } from "@opentui/core"
+
+ConsolePosition.TOP // Dock at top
+ConsolePosition.BOTTOM // Dock at bottom
+ConsolePosition.LEFT // Dock at left
+ConsolePosition.RIGHT // Dock at right
+```
+
+## Toggling the console
+
+Toggle the console overlay in code:
+
+```typescript
+// Toggle visibility and focus
+renderer.console.toggle()
+
+// When open but not focused, toggle() focuses the console
+// When focused, toggle() closes the console
+```
+
+## Console shortcuts
+
+When the console is focused:
+
+| Key        | Action                     |
+| ---------- | -------------------------- |
+| Arrow keys | Scroll through log history |
+| `+`        | Increase console size      |
+| `-`        | Decrease console size      |
+
+## Keybinding for toggle
+
+Add a keyboard shortcut to toggle the console:
+
+```typescript
+renderer.keyInput.on("keypress", (key) => {
+  // Toggle with backtick key
+  if (key.name === "`") {
+    renderer.console.toggle()
+  }
+
+  // Or with a modifier
+  if (key.ctrl && key.name === "l") {
+    renderer.console.toggle()
+  }
+})
+```
+
+## Why use the console?
+
+Terminal UI applications capture stdout for rendering. Regular `console.log` calls would interfere with your interface. The console overlay solves this problem:
+
+- Captures all console output without disrupting the UI
+- Displays logs in a dedicated overlay area
+- Color-codes different log levels for easy identification
+- Lets you scroll through history for debugging
+
+## Environment variables
+
+Control console behavior with environment variables:
+
+```bash
+# Disable console capture entirely
+OTUI_USE_CONSOLE=false bun app.ts
+
+# Start with console visible
+SHOW_CONSOLE=true bun app.ts
+
+# Dump captured output on exit
+OTUI_DUMP_CAPTURES=true bun app.ts
+```
diff --git a/.agents/skills/opentui/docs/core-concepts/constructs.mdx b/.agents/skills/opentui/docs/core-concepts/constructs.mdx
new file mode 100644
index 0000000..cb5096c
--- /dev/null
+++ b/.agents/skills/opentui/docs/core-concepts/constructs.mdx
@@ -0,0 +1,226 @@
+---
+title: Constructs
+description: Declarative component composition with VNodes
+order: 3
+---
+
+# Constructs
+
+Constructs let you compose your UI in a declarative, React-like way. They are factory functions that create VNodes (virtual nodes). A VNode is a lightweight description of a component. When you add a VNode to the tree, it becomes an actual Renderable.
+
+## Basic Usage
+
+Constructs look like function calls that return component descriptions:
+
+```typescript
+import { createCliRenderer, Box, Text, Input } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+renderer.root.add(
+  Box(
+    { width: 40, height: 10, borderStyle: "rounded", padding: 1 },
+    Text({ content: "Welcome!" }),
+    Input({ placeholder: "Enter your name..." }),
+  ),
+)
+```
+
+Pass children as additional arguments after the props object, not as a property.
+
+## Available Constructs
+
+Most core Renderable classes have matching construct functions:
+
+```typescript
+import {
+  ASCIIFont,
+  Box,
+  Code,
+  FrameBuffer,
+  Input,
+  ScrollBox,
+  Select,
+  SyntaxStyle,
+  TabSelect,
+  Text,
+  RGBA,
+} from "@opentui/core"
+
+// These create VNodes, not actual Renderables
+const syntaxStyle = SyntaxStyle.fromStyles({
+  default: { fg: RGBA.fromHex("#FFFFFF") },
+})
+const box = Box({ border: true })
+const text = Text({ content: "Hello" })
+const input = Input({ placeholder: "Type here..." })
+const code = Code({ content: "const x = 1", filetype: "typescript", syntaxStyle })
+const scrollBox = ScrollBox({ width: 40, height: 10 })
+const frameBuffer = FrameBuffer({ width: 20, height: 10 })
+const ascii = ASCIIFont({ text: "OPEN", font: "tiny" })
+```
+
+## How Constructs Work
+
+When you call a construct like `Box()`, it creates a VNode - a plain object describing what to create:
+
+```typescript
+// This creates a VNode, not an actual BoxRenderable
+const myBox = Box({ width: 20, height: 10 })
+
+// The VNode is instantiated when added to the tree
+renderer.root.add(myBox) // Now it becomes a real BoxRenderable
+```
+
+This deferred creation lets you:
+
+- Compose UI without a render context
+- Queue method calls before the component exists
+- Write cleaner, more declarative code
+
+## Creating Custom Constructs
+
+Create reusable components by writing functions that return VNodes:
+
+```typescript
+function LabeledInput(props: { label: string; placeholder: string }) {
+  return Box(
+    { flexDirection: "row", gap: 1 },
+    Text({ content: props.label }),
+    Input({ placeholder: props.placeholder, width: 20 }),
+  )
+}
+
+renderer.root.add(
+  Box(
+    { flexDirection: "column", padding: 1 },
+    LabeledInput({ label: "Name:", placeholder: "Enter name..." }),
+    LabeledInput({ label: "Email:", placeholder: "Enter email..." }),
+  ),
+)
+```
+
+## Method Chaining on VNodes
+
+VNodes support method calls. The system queues these calls and applies them after creating the component:
+
+```typescript
+const input = Input({ id: "my-input", placeholder: "Type here..." })
+
+// The VNode queues this call
+input.focus()
+
+// When added, the system creates the input and calls focus()
+renderer.root.add(input)
+```
+
+You can also set properties:
+
+```typescript
+const box = Box({ id: "my-box" })
+box.backgroundColor = RGBA.fromHex("#333366")
+renderer.root.add(box)
+```
+
+## The delegate() Function
+
+Composite components often need outer method calls to reach a specific inner component. The `delegate()` function maps method and property names to descendant IDs:
+
+```typescript
+import { delegate, Box, Text, Input } from "@opentui/core"
+
+function LabeledInput(props: { id: string; label: string; placeholder: string }) {
+  return delegate(
+    {
+      focus: `${props.id}-input`, // Route focus() to the input
+      value: `${props.id}-input`, // Route value property access
+    },
+    Box(
+      { flexDirection: "row" },
+      Text({ content: props.label }),
+      Input({
+        id: `${props.id}-input`,
+        placeholder: props.placeholder,
+        width: 20,
+      }),
+    ),
+  )
+}
+
+const username = LabeledInput({ id: "username", label: "Username:", placeholder: "Enter username..." })
+
+// This actually focuses the nested Input, not the outer Box
+username.focus()
+
+renderer.root.add(username)
+```
+
+### Delegate Mappings
+
+The mapping object's keys are method or property names, and the values are descendant IDs:
+
+```typescript
+delegate(
+  {
+    focus: "inner-input", // .focus() -> find descendant "inner-input" and call focus()
+    blur: "inner-input", // .blur() -> same
+    add: "content-area", // .add() -> add children to "content-area" instead
+    value: "inner-input", // .value get/set -> proxy to "inner-input"
+  },
+  vnode,
+)
+```
+
+## Composing with Children
+
+Custom constructs can accept and pass through children:
+
+```typescript
+function Card(props: { title: string }, ...children: VChild[]) {
+  return Box(
+    { border: true, padding: 1, flexDirection: "column" },
+    Text({ content: props.title, fg: "#FFFF00" }),
+    Box({ flexDirection: "column" }, ...children),
+  )
+}
+
+renderer.root.add(Card({ title: "User Info" }, Text({ content: "Name: Alice" }), Text({ content: "Role: Admin" })))
+```
+
+## Mixing Renderables and Constructs
+
+You can mix both approaches:
+
+```typescript
+import { BoxRenderable, Text, Input } from "@opentui/core"
+
+// Create a renderable directly
+const container = new BoxRenderable(renderer, {
+  id: "container",
+  flexDirection: "column",
+})
+
+// Add constructs to it
+container.add(Text({ content: "Title" }), Input({ placeholder: "Type here..." }))
+
+renderer.root.add(container)
+```
+
+Or use constructs that contain renderables:
+
+```typescript
+const customRenderable = new CustomRenderable(renderer, { id: "custom" })
+
+renderer.root.add(
+  Box(
+    { padding: 1 },
+    Text({ content: "Header" }),
+    customRenderable, // Regular renderable mixed in
+    Text({ content: "Footer" }),
+  ),
+)
+```
+
+## Next Steps
+
+See [Renderables vs Constructs](/docs/core-concepts/renderables-vs-constructs) for a detailed comparison of when to use each approach.
diff --git a/.agents/skills/opentui/docs/core-concepts/keyboard.mdx b/.agents/skills/opentui/docs/core-concepts/keyboard.mdx
new file mode 100644
index 0000000..227c5c1
--- /dev/null
+++ b/.agents/skills/opentui/docs/core-concepts/keyboard.mdx
@@ -0,0 +1,251 @@
+---
+title: Keyboard input
+description: Handling keyboard events in OpenTUI
+order: 6
+skill:
+  entry: true
+  intents: [keyboard, input, keybindings, paste, focus]
+---
+
+# Keyboard input
+
+OpenTUI parses terminal input and provides structured key events. The `renderer.keyInput` EventEmitter emits `keypress` events plus raw `paste` events with optional metadata.
+
+## Basic key handling
+
+```typescript
+import { createCliRenderer, type KeyEvent } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+const keyHandler = renderer.keyInput
+
+keyHandler.on("keypress", (key: KeyEvent) => {
+  console.log("Key name:", key.name)
+  console.log("Sequence:", key.sequence)
+  console.log("Ctrl pressed:", key.ctrl)
+  console.log("Shift pressed:", key.shift)
+  console.log("Alt pressed:", key.meta)
+  console.log("Option pressed:", key.option)
+})
+```
+
+## KeyEvent properties
+
+Each `KeyEvent` contains:
+
+| Property   | Type      | Description                              |
+| ---------- | --------- | ---------------------------------------- |
+| `name`     | `string`  | The key name (e.g., "a", "escape", "f1") |
+| `sequence` | `string`  | The raw escape sequence                  |
+| `ctrl`     | `boolean` | Whether Ctrl was held                    |
+| `shift`    | `boolean` | Whether Shift was held                   |
+| `meta`     | `boolean` | Whether Alt/Meta was held                |
+| `option`   | `boolean` | Whether Option was held (macOS)          |
+
+## Key aliases
+
+OpenTUI normalizes several key names so your keybindings work the same across layouts and input paths. OpenTUI applies aliases after the parser reports a key, before emitting `keypress`.
+
+The default aliases are:
+
+```ts
+// enter -> return
+// esc   -> escape
+//
+// Numpad keys are aliased to their main-keyboard equivalents:
+// kp0..kp9   -> "0".."9"
+// kpenter    -> enter  (then via enter -> return)
+// kpleft/kpright/kpup/kpdown -> arrow keys
+// kphome/kpend/kppageup/kppagedown/kpinsert/kpdelete -> navigation
+// kpdecimal/kpdivide/kpmultiply/kpminus/kpplus/kpequal/kpseparator -> symbols
+```
+
+Both `key.name === "enter"` and `key.name === "kpenter"` resolve to `"return"` when you match them with `matchesKeyBinding`. Editable components that accept a `keyAliasMap` option (`InputRenderable`, `TextareaRenderable`, `SelectRenderable`, etc.) merge these defaults with your own map:
+
+```typescript
+import { InputRenderable } from "@opentui/core"
+
+const input = new InputRenderable(renderer, {
+  id: "field",
+  keyAliasMap: {
+    // Treat the numpad decimal key as forward-delete
+    kpdecimal: "delete",
+  },
+})
+```
+
+## Common key patterns
+
+### Single keys
+
+```typescript
+keyHandler.on("keypress", (key: KeyEvent) => {
+  if (key.name === "escape") {
+    console.log("Escape pressed!")
+  }
+
+  if (key.name === "return") {
+    console.log("Enter pressed!")
+  }
+
+  if (key.name === "space") {
+    console.log("Space pressed!")
+  }
+})
+```
+
+### Modifier combinations
+
+```typescript
+keyHandler.on("keypress", (key: KeyEvent) => {
+  // Ctrl+C
+  if (key.ctrl && key.name === "c") {
+    console.log("Ctrl+C pressed!")
+  }
+
+  // Ctrl+S
+  if (key.ctrl && key.name === "s") {
+    console.log("Save shortcut!")
+  }
+
+  // Shift+F1
+  if (key.shift && key.name === "f1") {
+    console.log("Shift+F1 pressed!")
+  }
+
+  // Alt+Enter
+  if (key.meta && key.name === "return") {
+    console.log("Alt+Enter pressed!")
+  }
+})
+```
+
+### Function keys
+
+```typescript
+keyHandler.on("keypress", (key: KeyEvent) => {
+  // F1-F12
+  if (key.name === "f1") {
+    showHelp()
+  }
+
+  if (key.name === "f5") {
+    refresh()
+  }
+})
+```
+
+### Arrow keys
+
+```typescript
+keyHandler.on("keypress", (key: KeyEvent) => {
+  switch (key.name) {
+    case "up":
+      moveCursorUp()
+      break
+    case "down":
+      moveCursorDown()
+      break
+    case "left":
+      moveCursorLeft()
+      break
+    case "right":
+      moveCursorRight()
+      break
+  }
+})
+```
+
+## Paste events
+
+Handle pasted bytes separately from individual keypresses. Decode them explicitly when you expect text:
+
+```typescript
+import { type PasteEvent } from "@opentui/core"
+
+const textDecoder = new TextDecoder()
+
+keyHandler.on("paste", (event: PasteEvent) => {
+  console.log("Pasted bytes:", event.bytes)
+  console.log("Decoded text:", textDecoder.decode(event.bytes))
+  console.log("Metadata:", event.metadata)
+})
+```
+
+## Exit on Ctrl+C
+
+Configure the renderer to automatically exit on Ctrl+C:
+
+```typescript
+const renderer = await createCliRenderer({
+  exitOnCtrlC: true, // Default behavior
+})
+
+// Or handle it manually
+const renderer = await createCliRenderer({
+  exitOnCtrlC: false,
+})
+
+renderer.keyInput.on("keypress", (key: KeyEvent) => {
+  if (key.ctrl && key.name === "c") {
+    // Custom cleanup before shutdown
+    cleanup()
+    renderer.destroy()
+  }
+})
+```
+
+## Kitty keyboard protocol
+
+OpenTUI opts into the [kitty keyboard protocol](https://sw.kovidgoyal.net/kitty/keyboard-protocol/) when the terminal supports it. The protocol gives more reliable key names and modifier state than legacy input encoding, including release events, disambiguated escape, alt+key sequences, and alternate keys for cross-layout shortcuts. Configure it with the `useKittyKeyboard` option:
+
+```typescript
+const renderer = await createCliRenderer({
+  useKittyKeyboard: {
+    disambiguate: true,
+    alternateKeys: true,
+    events: true, // press/repeat/release
+    allKeysAsEscapes: false,
+    reportText: false,
+  },
+})
+
+// Disable entirely:
+await createCliRenderer({ useKittyKeyboard: null })
+```
+
+| Option             | Default | Flag                              | Description                                                                    |
+| ------------------ | ------- | --------------------------------- | ------------------------------------------------------------------------------ |
+| `disambiguate`     | `true`  | `DISAMBIGUATE_ESCAPE_CODES`       | Fixes ESC timing and alt+key ambiguity; reports `ctrl+c` as a proper key event |
+| `alternateKeys`    | `true`  | `REPORT_ALTERNATE_KEYS`           | Reports shifted/base-layout keys for cross-layout shortcuts                    |
+| `events`           | `false` | `REPORT_EVENT_TYPES`              | Report press, repeat, and release events                                       |
+| `allKeysAsEscapes` | `false` | `REPORT_ALL_KEYS_AS_ESCAPE_CODES` | Encode every key as an escape sequence                                         |
+| `reportText`       | `false` | `REPORT_ASSOCIATED_TEXT`          | Include the text a key press generates                                         |
+
+`events: true` enables the `keyrelease` event on `renderer.keyInput` as well as `eventType` on `KeyEvent`.
+
+`useKittyKeyboard: {}` applies the defaults (`disambiguate` + `alternateKeys`). Passing `null` disables the protocol entirely.
+
+## Focus and key routing
+
+Focus components to receive keyboard input. OpenTUI routes events to the focused component:
+
+```typescript
+import { InputRenderable } from "@opentui/core"
+
+const input = new InputRenderable(renderer, {
+  id: "my-input",
+  placeholder: "Type here...",
+})
+
+// Focus the input to receive key events
+input.focus()
+
+// Or with constructs
+import { Input } from "@opentui/core"
+
+const inputNode = Input({ placeholder: "Type here..." })
+inputNode.focus() // Queued for when instantiated
+
+renderer.root.add(inputNode)
+```
diff --git a/.agents/skills/opentui/docs/core-concepts/layout.mdx b/.agents/skills/opentui/docs/core-concepts/layout.mdx
new file mode 100644
index 0000000..d74a207
--- /dev/null
+++ b/.agents/skills/opentui/docs/core-concepts/layout.mdx
@@ -0,0 +1,255 @@
+---
+title: Layout System
+description: Flexible positioning and sizing with Yoga/Flexbox
+order: 5
+skill:
+  entry: true
+  intents: [layout, flexbox, yoga, positioning]
+---
+
+# Layout System
+
+OpenTUI uses the Yoga layout engine to provide CSS Flexbox-like capabilities for responsive terminal layouts. You can create complex, dynamic interfaces that adapt to terminal size changes.
+
+## Flexbox Basics
+
+The layout system supports standard flexbox properties:
+
+```typescript
+import { BoxRenderable, createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const container = new BoxRenderable(renderer, {
+  id: "container",
+  flexDirection: "row",
+  justifyContent: "space-between",
+  alignItems: "center",
+  width: "100%",
+  height: 10,
+})
+
+const leftPanel = new BoxRenderable(renderer, {
+  id: "left",
+  flexGrow: 1,
+  height: 10,
+  backgroundColor: "#444",
+})
+
+const rightPanel = new BoxRenderable(renderer, {
+  id: "right",
+  width: 20,
+  height: 10,
+  backgroundColor: "#666",
+})
+
+container.add(leftPanel)
+container.add(rightPanel)
+renderer.root.add(container)
+```
+
+## Flex Direction
+
+Control the direction of child elements:
+
+```typescript
+// Vertical layout (default)
+{
+  flexDirection: "column"
+}
+
+// Horizontal layout
+{
+  flexDirection: "row"
+}
+
+// Reversed directions
+{
+  flexDirection: "row-reverse"
+}
+{
+  flexDirection: "column-reverse"
+}
+```
+
+## Justify Content
+
+Align children along the main axis:
+
+```typescript
+{
+  justifyContent: "flex-start"
+} // Pack at start
+{
+  justifyContent: "flex-end"
+} // Pack at end
+{
+  justifyContent: "center"
+} // Center children
+{
+  justifyContent: "space-between"
+} // Even spacing, no edge gaps
+{
+  justifyContent: "space-around"
+} // Even spacing with edge gaps
+{
+  justifyContent: "space-evenly"
+} // Truly even spacing
+```
+
+## Align Items
+
+Align children along the cross axis:
+
+```typescript
+{
+  alignItems: "flex-start"
+} // Align to start
+{
+  alignItems: "flex-end"
+} // Align to end
+{
+  alignItems: "center"
+} // Center on cross axis
+{
+  alignItems: "stretch"
+} // Stretch to fill (default)
+{
+  alignItems: "baseline"
+} // Align baselines
+```
+
+## Sizing
+
+### Fixed Sizes
+
+```typescript
+{
+  width: 30,   // Fixed width in characters
+  height: 10,  // Fixed height in rows
+}
+```
+
+### Percentage Sizes
+
+```typescript
+{
+  width: "100%",  // Full width of parent
+  height: "50%",  // Half height of parent
+}
+```
+
+### Flex Growing and Shrinking
+
+```typescript
+{
+  flexGrow: 1,    // Take up available space
+  flexShrink: 0,  // Don't shrink below content size
+  flexBasis: 100, // Initial size before flex adjustments
+}
+```
+
+## Positioning
+
+### Relative (Default)
+
+Elements flow normally in the layout:
+
+```typescript
+{
+  position: "relative",
+}
+```
+
+### Absolute
+
+Position elements relative to their parent:
+
+```typescript
+{
+  position: "absolute",
+  left: 10,
+  top: 5,
+  right: 10,
+  bottom: 5,
+}
+```
+
+## Padding and Margin
+
+```typescript
+{
+  // Uniform padding
+  padding: 2,
+
+  // Axis-specific
+  paddingX: 4,
+  paddingY: 2,
+
+  // Individual sides
+  paddingTop: 1,
+  paddingRight: 2,
+  paddingBottom: 1,
+  paddingLeft: 2,
+
+  // Margin works the same way
+  margin: 1,
+  marginX: 3,
+  marginY: 1,
+  marginTop: 1,
+  marginRight: 2,
+  marginBottom: 1,
+  marginLeft: 2,
+}
+```
+
+## Using Constructs
+
+The same layout properties work with the declarative API:
+
+```typescript
+import { Box, Text } from "@opentui/core"
+
+renderer.root.add(
+  Box(
+    {
+      flexDirection: "row",
+      width: "100%",
+      height: 10,
+    },
+    Box(
+      {
+        flexGrow: 1,
+        backgroundColor: "#333",
+        padding: 1,
+      },
+      Text({ content: "Left Panel" }),
+    ),
+    Box(
+      {
+        width: 20,
+        backgroundColor: "#555",
+        padding: 1,
+      },
+      Text({ content: "Right Panel" }),
+    ),
+  ),
+)
+```
+
+## Responsive Layouts
+
+Listen for terminal resize events to create responsive layouts:
+
+```typescript
+const renderer = await createCliRenderer()
+
+renderer.on("resize", (width, height) => {
+  // Update layout based on new dimensions
+  if (width < 80) {
+    container.flexDirection = "column"
+  } else {
+    container.flexDirection = "row"
+  }
+})
+```
diff --git a/.agents/skills/opentui/docs/core-concepts/lifecycle.mdx b/.agents/skills/opentui/docs/core-concepts/lifecycle.mdx
new file mode 100644
index 0000000..7216ecb
--- /dev/null
+++ b/.agents/skills/opentui/docs/core-concepts/lifecycle.mdx
@@ -0,0 +1,124 @@
+---
+title: Lifecycle and cleanup
+description: Managing renderer lifecycle and terminal cleanup
+order: 10
+---
+
+# Lifecycle and cleanup
+
+OpenTUI gives you control over terminal cleanup. Call `renderer.destroy()` when you shut down. It restores the terminal to its original state, and it frees resources.
+
+## Why you must handle cleanup
+
+OpenTUI does not automatically clean up on `process.exit` or unhandled errors. This design gives you more control over shutdown behavior:
+
+- You may want to handle errors and keep running
+- You may use effect systems, like Effect.ts, with their own shutdown handling
+- You may need custom cleanup order or additional shutdown logic
+
+## Use `renderer.destroy()`
+
+Call `destroy()` when your app exits:
+
+```typescript
+import { createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+// ... your application code ...
+
+// Clean shutdown
+renderer.destroy()
+```
+
+For reliable cleanup, keep renderer teardown in the same control flow as your app startup:
+
+```typescript
+import { createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+try {
+  // ... your application code ...
+} finally {
+  renderer.destroy()
+}
+```
+
+## Signal handling
+
+OpenTUI listens for common exit signals and calls `destroy()` when it receives them. By default, it handles these signals:
+
+| Signal     | Description              |
+| ---------- | ------------------------ |
+| `SIGINT`   | Ctrl+C                   |
+| `SIGTERM`  | Termination signal       |
+| `SIGQUIT`  | Ctrl+\                   |
+| `SIGABRT`  | Abort signal             |
+| `SIGHUP`   | Hangup (terminal closed) |
+| `SIGBREAK` | Ctrl+Break on Windows    |
+| `SIGPIPE`  | Broken pipe              |
+| `SIGBUS`   | Bus error                |
+
+You can customize which signals trigger cleanup:
+
+```typescript
+// Only handle SIGINT and SIGTERM
+const renderer = await createCliRenderer({
+  exitSignals: ["SIGINT", "SIGTERM"],
+})
+
+// Disable all signal-based cleanup (handle it yourself)
+const renderer = await createCliRenderer({
+  exitSignals: [],
+})
+```
+
+## Ctrl+C behavior
+
+By default, Ctrl+C calls `destroy()`. If you want to handle Ctrl+C yourself, disable the internal handler and remove `SIGINT` from `exitSignals`:
+
+```typescript
+const renderer = await createCliRenderer({
+  exitOnCtrlC: false,
+  exitSignals: ["SIGTERM", "SIGQUIT", "SIGABRT", "SIGHUP", "SIGBREAK", "SIGPIPE", "SIGBUS"],
+})
+
+renderer.keyInput.on("keypress", (key) => {
+  if (key.ctrl && key.name === "c") {
+    // Custom Ctrl+C handling
+    console.log("Ctrl+C pressed, but not exiting")
+  }
+})
+```
+
+## Destroy callback
+
+Run custom logic when the renderer is destroyed:
+
+```typescript
+const renderer = await createCliRenderer({
+  onDestroy: () => {
+    console.log("Renderer destroyed, performing additional cleanup...")
+  },
+})
+```
+
+## What `destroy()` cleans up
+
+The `destroy()` method cleans up these resources:
+
+- Removes the signal and process listeners that OpenTUI adds
+- Clears timers and render loops
+- Destroys all renderables in the tree
+- Restores stdin raw mode
+- Resets terminal state (cursor, alternate screen, etc.)
+- Frees native resources
+
+## Troubleshooting
+
+If your terminal stays in a broken state after a crash:
+
+1. Run `reset` in your terminal to restore it
+2. Add `uncaughtException` and `unhandledRejection` handlers to your app
+3. Make sure you call `renderer.destroy()` in all exit paths
diff --git a/.agents/skills/opentui/docs/core-concepts/notifications.mdx b/.agents/skills/opentui/docs/core-concepts/notifications.mdx
new file mode 100644
index 0000000..b6e04b8
--- /dev/null
+++ b/.agents/skills/opentui/docs/core-concepts/notifications.mdx
@@ -0,0 +1,35 @@
+---
+title: Notifications
+description: Trigger terminal-mediated desktop notifications
+order: 8
+skill:
+  intents: [notifications, terminal, osc, renderer]
+---
+
+# Notifications
+
+OpenTUI can ask the terminal emulator to show a desktop notification using OSC escape sequences. Use this for long-running tasks, background work, or prompts that need attention.
+
+```typescript
+const ok = renderer.triggerNotification("Build finished", "OpenTUI")
+```
+
+`triggerNotification(message, title?)` returns `true` when OpenTUI has detected a supported notification protocol, and `false` otherwise.
+
+## Capability
+
+Check detection state through renderer capabilities:
+
+```typescript
+if (renderer.capabilities?.notifications) {
+  renderer.triggerNotification("Tests passed", "CI")
+}
+```
+
+OpenTUI detects and emits terminal OSC notification protocols only. It does not call platform tools such as `notify-send`, AppleScript, or PowerShell toasts.
+
+## Terminal behavior
+
+Terminal and OS settings decide how the notification is presented. Some terminals only show banners when the terminal is unfocused, and macOS may store notifications in Notification Center without showing a banner depending on app notification settings.
+
+See `packages/examples/src/notification-demo.ts` for an interactive example.
diff --git a/.agents/skills/opentui/docs/core-concepts/renderables-vs-constructs.mdx b/.agents/skills/opentui/docs/core-concepts/renderables-vs-constructs.mdx
new file mode 100644
index 0000000..27439fe
--- /dev/null
+++ b/.agents/skills/opentui/docs/core-concepts/renderables-vs-constructs.mdx
@@ -0,0 +1,183 @@
+---
+title: Renderables vs Constructs
+description: Two approaches to building UIs in OpenTUI
+order: 4
+---
+
+# Renderables vs Constructs
+
+OpenTUI provides two ways to build your UI: the imperative Renderable API and the declarative Construct API. Both approaches have different tradeoffs.
+
+## Imperative (Renderables)
+
+You create `Renderable` instances with a `RenderContext` and compose them using `add()`. You mutate state and behavior directly on instances through setters and methods.
+
+```typescript
+import { BoxRenderable, TextRenderable, InputRenderable, createCliRenderer, type RenderContext } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const loginForm = new BoxRenderable(renderer, {
+  id: "login-form",
+  width: 40,
+  height: 10,
+  padding: 1,
+})
+
+// Compose multiple renderables into one
+function createLabeledInput(renderer: RenderContext, props: { label: string; placeholder: string; id: string }) {
+  const container = new BoxRenderable(renderer, {
+    id: `${props.id}-container`,
+    flexDirection: "row",
+  })
+
+  container.add(
+    new TextRenderable(renderer, {
+      id: `${props.id}-label`,
+      content: props.label + " ",
+    }),
+  )
+
+  container.add(
+    new InputRenderable(renderer, {
+      id: `${props.id}-input`,
+      placeholder: props.placeholder,
+      width: 20,
+    }),
+  )
+
+  return container
+}
+
+const username = createLabeledInput(renderer, {
+  id: "username",
+  label: "Username:",
+  placeholder: "Enter username...",
+})
+loginForm.add(username)
+
+// You must navigate to the nested component to focus it
+username.getRenderable("username-input")?.focus()
+
+renderer.root.add(loginForm)
+```
+
+### Characteristics
+
+- Requires `RenderContext` at creation time
+- Direct mutation of instances
+- Manual navigation for nested component access
+- Explicit control over component lifecycle
+
+## Declarative (Constructs)
+
+Builds a lightweight VNode graph using functional constructs. Instances don't exist until you add the node to the tree. VNodes queue method calls and replay them when instantiated.
+
+```typescript
+import { Text, Input, Box, createCliRenderer, delegate } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+function LabeledInput(props: { id: string; label: string; placeholder: string }) {
+  return delegate(
+    { focus: `${props.id}-input` },
+    Box(
+      { flexDirection: "row" },
+      Text({ content: props.label + " " }),
+      Input({
+        id: `${props.id}-input`,
+        placeholder: props.placeholder,
+        width: 20,
+      }),
+    ),
+  )
+}
+
+const usernameInput = LabeledInput({
+  id: "username",
+  label: "Username:",
+  placeholder: "Enter username...",
+})
+
+// delegate() automatically routes focus to the nested input
+usernameInput.focus()
+
+const loginForm = Box(
+  { width: 40, height: 10, padding: 1 },
+  usernameInput,
+  LabeledInput({
+    id: "password",
+    label: "Password:",
+    placeholder: "Enter password...",
+  }),
+)
+
+renderer.root.add(loginForm)
+```
+
+### Characteristics
+
+- No `RenderContext` needed until instantiation
+- VNodes queue method calls
+- `delegate()` routes APIs to nested components
+- Declarative, React-like syntax
+
+## The delegate() function
+
+The `delegate()` function makes constructs ergonomic by routing method calls from the parent to specific children:
+
+```typescript
+function Button(props: { id: string; label: string; onClick: () => void }) {
+  return delegate(
+    {
+      focus: `${props.id}-box`, // Route focus() to the box
+    },
+    Box(
+      {
+        id: `${props.id}-box`,
+        border: true,
+        onMouseDown: props.onClick,
+      },
+      Text({ content: props.label }),
+    ),
+  )
+}
+
+const button = Button({ id: "submit", label: "Submit", onClick: handleSubmit })
+button.focus() // Focuses the inner Box
+```
+
+## When to use which
+
+### Use Renderables when
+
+- You need fine-grained control over component lifecycle
+- You're building low-level custom components
+- You need to access renderable methods immediately
+- Performance is critical and you want to avoid VNode overhead
+
+### Use Constructs when
+
+- You prefer declarative, compositional code
+- You're building higher-level UI components
+- You want cleaner, more readable component definitions
+- You're familiar with React/Solid patterns
+
+## Mixing both
+
+You can mix both approaches in the same application:
+
+```typescript
+import { BoxRenderable, Text, Input } from "@opentui/core"
+
+// Create a renderable container
+const container = new BoxRenderable(renderer, {
+  id: "container",
+  flexDirection: "column",
+})
+
+// Add constructs to it
+container.add(Text({ content: "Title" }), Input({ placeholder: "Type here..." }))
+
+renderer.root.add(container)
+```
diff --git a/.agents/skills/opentui/docs/core-concepts/renderables.mdx b/.agents/skills/opentui/docs/core-concepts/renderables.mdx
new file mode 100644
index 0000000..8b56974
--- /dev/null
+++ b/.agents/skills/opentui/docs/core-concepts/renderables.mdx
@@ -0,0 +1,358 @@
+---
+title: Renderables
+description: The building blocks of your terminal UI
+order: 2
+---
+
+# Renderables
+
+Renderables are the building blocks of your UI. You can position, style, and nest them within each other. Each renderable represents a visual element and uses the Yoga layout engine for flexible positioning and sizing.
+
+## Creating Renderables
+
+Create a renderable by instantiating a class with a render context (the renderer) and options:
+
+```typescript
+import { createCliRenderer, TextRenderable, BoxRenderable } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+
+const greeting = new TextRenderable(renderer, {
+  id: "greeting",
+  content: "Hello, OpenTUI!",
+  fg: "#00FF00",
+})
+
+renderer.root.add(greeting)
+```
+
+## Available Renderables
+
+OpenTUI provides these built-in renderables:
+
+| Class                   | Description                                   |
+| ----------------------- | --------------------------------------------- |
+| `BoxRenderable`         | Container with border, background, and layout |
+| `TextRenderable`        | Read-only styled text display                 |
+| `InputRenderable`       | Single-line text input                        |
+| `TextareaRenderable`    | Multi-line editable text                      |
+| `SelectRenderable`      | Dropdown/list selection                       |
+| `TabSelectRenderable`   | Horizontal tab selection                      |
+| `ScrollBoxRenderable`   | Scrollable container                          |
+| `ScrollBarRenderable`   | Standalone scroll bar control                 |
+| `CodeRenderable`        | Syntax-highlighted code display               |
+| `LineNumberRenderable`  | Line number gutter for code/text views        |
+| `DiffRenderable`        | Unified or split diff viewer                  |
+| `ASCIIFontRenderable`   | ASCII art font display                        |
+| `FrameBufferRenderable` | Raw framebuffer for custom graphics           |
+| `MarkdownRenderable`    | Markdown renderer                             |
+| `SliderRenderable`      | Numeric slider control                        |
+
+## The Renderable Tree
+
+Renderables form a tree structure. Use `add()` and `remove()` to manage children:
+
+```typescript
+const container = new BoxRenderable(renderer, {
+  id: "container",
+  flexDirection: "column",
+  padding: 1,
+})
+
+const title = new TextRenderable(renderer, { id: "title", content: "My App" })
+const body = new TextRenderable(renderer, { id: "body", content: "Content here" })
+
+container.add(title)
+container.add(body)
+
+renderer.root.add(container)
+
+// Later, remove a child
+container.remove("body")
+```
+
+## Finding Renderables
+
+Navigate the tree to find specific renderables:
+
+```typescript
+// Get a direct child by ID
+const title = container.getRenderable("title")
+
+// Recursively search all descendants
+const deepChild = container.findDescendantById("nested-input")
+
+// Get all children
+const children = container.getChildren()
+```
+
+## Layout Properties
+
+All renderables support Yoga flexbox properties:
+
+```typescript
+const panel = new BoxRenderable(renderer, {
+  id: "panel",
+
+  // Sizing
+  width: 40,
+  height: "50%",
+  minWidth: 20,
+  maxHeight: 30,
+
+  // Flex behavior
+  flexGrow: 1,
+  flexShrink: 0,
+  flexDirection: "column",
+  justifyContent: "center",
+  alignItems: "flex-start",
+
+  // Positioning
+  position: "absolute",
+  left: 10,
+  top: 5,
+
+  // Spacing
+  padding: 2,
+  paddingTop: 1,
+  margin: 1,
+})
+```
+
+See the [Layout](/docs/core-concepts/layout) page for complete details.
+
+## Focus Management
+
+Interactive renderables can receive keyboard focus:
+
+```typescript
+const input = new InputRenderable(renderer, {
+  id: "username",
+  placeholder: "Enter username...",
+})
+
+renderer.root.add(input)
+
+// Give focus to the input
+input.focus()
+
+// Remove focus
+input.blur()
+
+// Check focus state
+console.log(input.focused) // true
+```
+
+By default, left-clicking a renderable will auto-focus the closest focusable ancestor. Disable this globally with
+`createCliRenderer({ autoFocus: false })`, or stop it per interaction by calling `event.preventDefault()` in
+`onMouseDown`.
+
+Listen for focus changes:
+
+```typescript
+import { RenderableEvents } from "@opentui/core"
+
+input.on(RenderableEvents.FOCUSED, () => {
+  console.log("Input focused")
+})
+
+input.on(RenderableEvents.BLURRED, () => {
+  console.log("Input blurred")
+})
+```
+
+### Focused descendants
+
+A renderable can also react to focus living inside one of its descendants through the `hasFocusedDescendant` flag. When any child has focus, every ancestor's `hasFocusedDescendant` flips to `true` and OpenTUI marks them dirty so they repaint. `BoxRenderable` uses this to paint the `focusedBorderColor` whenever the box itself is focusable and any descendant currently owns focus:
+
+```typescript
+const panel = new BoxRenderable(renderer, {
+  id: "panel",
+  focusable: true,
+  borderColor: "#444",
+  focusedBorderColor: "#00AAFF",
+  flexDirection: "column",
+})
+
+const input = new InputRenderable(renderer, { id: "panel-input" })
+panel.add(input)
+
+input.focus() // panel.hasFocusedDescendant === true → border recolors
+```
+
+Custom renderables can read `this._hasFocusedDescendant` (protected) or `renderable.hasFocusedDescendant` (public) to add similar effects.
+
+## Event Handling
+
+### Mouse Events
+
+Handle mouse interactions via options:
+
+```typescript
+const button = new BoxRenderable(renderer, {
+  id: "button",
+  border: true,
+  onMouseDown: (event) => {
+    console.log("Clicked at", event.x, event.y)
+  },
+  onMouseOver: (event) => {
+    button.borderColor = "#FFFF00"
+  },
+  onMouseOut: (event) => {
+    button.borderColor = "#FFFFFF"
+  },
+})
+```
+
+Available mouse events:
+
+- `onMouseDown`, `onMouseUp`
+- `onMouseMove`, `onMouseDrag`, `onMouseDragEnd`, `onMouseDrop`
+- `onMouseOver`, `onMouseOut`
+- `onMouseScroll`
+- `onMouse` (catch-all)
+
+Mouse events bubble up through the tree. Stop propagation with `event.stopPropagation()`.
+
+### Keyboard Events
+
+For focusable renderables:
+
+```typescript
+const textDecoder = new TextDecoder()
+
+const input = new InputRenderable(renderer, {
+  id: "input",
+  onKeyDown: (key) => {
+    if (key.name === "escape") {
+      input.blur()
+    }
+  },
+  onPaste: (event) => {
+    console.log("Pasted:", textDecoder.decode(event.bytes))
+  },
+})
+```
+
+## Visibility
+
+Control visibility with the `visible` property:
+
+```typescript
+// Hide (also removes from layout)
+panel.visible = false
+
+// Show
+panel.visible = true
+```
+
+When `visible` is `false`, Yoga excludes the renderable from layout calculation (equivalent to CSS `display: none`).
+
+## Opacity
+
+Set opacity for semi-transparent rendering:
+
+```typescript
+panel.opacity = 0.5 // 50% transparent
+```
+
+Opacity affects the renderable and all its children.
+
+## Z-Index
+
+Control layering order for overlapping elements:
+
+```typescript
+const overlay = new BoxRenderable(renderer, {
+  id: "overlay",
+  position: "absolute",
+  zIndex: 100, // Higher values render on top
+})
+```
+
+## Live Rendering
+
+For animations, extend the Renderable class and override `onUpdate`:
+
+```typescript
+class AnimatedBox extends BoxRenderable {
+  onUpdate(deltaTime) {
+    // Update animation state
+    this.translateX += 1
+  }
+}
+
+const box = new AnimatedBox(renderer, {
+  id: "anim-box",
+  live: true, // Enable continuous rendering
+})
+```
+
+## Translation
+
+Offset a renderable from its layout position (useful for scrolling/animation):
+
+```typescript
+// Offset by pixels
+renderable.translateX = 10
+renderable.translateY = -5
+```
+
+This moves the renderable visually without affecting layout.
+
+## Buffered Rendering
+
+Enable offscreen rendering for complex content and use hooks to draw to the buffer:
+
+```typescript
+import { RGBA } from "@opentui/core"
+
+const complex = new BoxRenderable(renderer, {
+  id: "complex",
+  buffered: true, // Render to offscreen buffer first
+  renderAfter: (buffer) => {
+    // Draw directly to the buffer (or offscreen buffer if buffered=true)
+    buffer.fillRect(0, 0, 10, 5, RGBA.fromHex("#FF0000"))
+  },
+})
+```
+
+## Lifecycle Methods
+
+Override these methods in custom renderables:
+
+```typescript
+class CustomRenderable extends Renderable {
+  // Called each frame before rendering
+  onUpdate(deltaTime: number) {
+    // Update state, animations, etc.
+  }
+
+  // Called when dimensions change
+  onResize(width: number, height: number) {
+    // Respond to size changes
+  }
+
+  // Called when removed from parent
+  onRemove() {
+    // Cleanup
+  }
+
+  // Override for custom rendering
+  renderSelf(buffer: OptimizedBuffer, deltaTime: number) {
+    // Draw to buffer
+  }
+}
+```
+
+## Destroying Renderables
+
+Clean up a renderable and remove it from the tree:
+
+```typescript
+// Remove from parent and free resources
+renderable.destroy()
+
+// Destroy self and all children
+container.destroyRecursively()
+```
diff --git a/.agents/skills/opentui/docs/core-concepts/renderer.mdx b/.agents/skills/opentui/docs/core-concepts/renderer.mdx
new file mode 100644
index 0000000..1a36cc4
--- /dev/null
+++ b/.agents/skills/opentui/docs/core-concepts/renderer.mdx
@@ -0,0 +1,561 @@
+---
+title: Renderer
+description: CliRenderer manages terminal output and the render loop
+order: 1
+skill:
+  entry: true
+  intents: [core, renderer, terminal, scrollback, lifecycle]
+---
+
+# Renderer
+
+The `CliRenderer` drives OpenTUI. It manages terminal output, handles input events, runs the rendering loop, and provides context for creating renderables.
+
+## Creating a renderer
+
+Create a renderer with the async factory function:
+
+```typescript
+import { createCliRenderer } from "@opentui/core"
+
+const renderer = await createCliRenderer({
+  exitOnCtrlC: true,
+  targetFps: 30,
+})
+```
+
+The factory function does three things:
+
+1. Loads the native Zig rendering library
+2. Configures terminal settings (mouse, keyboard protocol, and the selected screen mode)
+3. Returns an initialized `CliRenderer` instance
+
+## Configuration options
+
+This page covers the options that most apps set directly.
+`CliRendererConfig` also includes lower-level hooks for testing and tuning, such as `stdin`, `stdout`, `clock`,
+`postProcessFns`, and `prependInputHandlers`.
+
+| Option                | Type                           | Default              | Description                                                                             |
+| --------------------- | ------------------------------ | -------------------- | --------------------------------------------------------------------------------------- |
+| `screenMode`          | `ScreenMode`                   | `"alternate-screen"` | How the renderer uses terminal space ([details](#screen-modes))                         |
+| `footerHeight`        | `number`                       | `12`                 | Requested footer rows for `"split-footer"` mode                                         |
+| `externalOutputMode`  | `ExternalOutputMode`           | varies               | How writes to `stdout.write` are handled ([details](#external-output-mode))             |
+| `consoleMode`         | `ConsoleMode`                  | `"console-overlay"`  | How the built-in console overlay behaves ([details](#console-mode))                     |
+| `exitOnCtrlC`         | `boolean`                      | `true`               | Call `renderer.destroy()` when Ctrl+C is pressed                                        |
+| `exitSignals`         | `NodeJS.Signals[]`             | see below            | Signals that trigger cleanup ([details](/docs/core-concepts/lifecycle#signal-handling)) |
+| `clearOnShutdown`     | `boolean`                      | `true`               | Clear the renderer-owned region on `suspend()` and `destroy()`                          |
+| `targetFps`           | `number`                       | `30`                 | Target frames per second for the render loop                                            |
+| `maxFps`              | `number`                       | `60`                 | Maximum FPS cap for immediate re-renders                                                |
+| `useMouse`            | `boolean`                      | `true`               | Enable mouse input                                                                      |
+| `autoFocus`           | `boolean`                      | `true`               | Focus the nearest focusable renderable on left click                                    |
+| `enableMouseMovement` | `boolean`                      | `true`               | Track mouse movement, not just clicks and scrolls                                       |
+| `useKittyKeyboard`    | `KittyKeyboardOptions \| null` | `{}`                 | Kitty keyboard protocol settings, or `null` to disable                                  |
+| `backgroundColor`     | `ColorInput`                   | transparent          | Background color for the render buffer                                                  |
+| `consoleOptions`      | `ConsoleOptions`               | -                    | Options forwarded to the built-in console overlay                                       |
+| `openConsoleOnError`  | `boolean`                      | `true` (dev)         | Open the console overlay on uncaught errors                                             |
+| `onDestroy`           | `() => void`                   | -                    | Run after the renderer finishes cleanup                                                 |
+
+You can also change `screenMode`, `footerHeight`, `externalOutputMode`, and `consoleMode` at runtime through their
+matching `renderer` properties.
+
+## Screen modes
+
+The `screenMode` option controls whether OpenTUI owns the alternate screen or a reserved region of the main screen. You
+can also change modes at runtime by setting `renderer.screenMode`.
+
+### `"alternate-screen"` (default)
+
+Switches to the terminal's alternate screen buffer. The original scrollback content is preserved and restored when the
+renderer exits. This is the standard mode for full-screen TUI applications.
+
+```typescript
+const renderer = await createCliRenderer({
+  screenMode: "alternate-screen",
+})
+```
+
+### `"main-screen"`
+
+Renders on the terminal's main screen without switching buffers. OpenTUI still reserves a render region by scrolling terminal content, so this is not a true scrollback-native inline or direct renderer. Use it when you want the UI to stay on the main screen for testing, benchmarks, or short-lived tools.
+
+```typescript
+const renderer = await createCliRenderer({
+  screenMode: "main-screen",
+})
+```
+
+### `"split-footer"`
+
+Pins the renderer to a reserved footer region at the bottom of the terminal. The area above the footer stays available for normal program output. This is the closest thing OpenTUI currently has to a direct-render mode, but it still uses the same buffered main-screen renderer rather than a separate inline backend.
+
+The `footerHeight` option controls how many rows the footer requests (default: 12). When using split-footer mode, `externalOutputMode` defaults to `"capture-stdout"` so that writes to `stdout.write` can be replayed above the footer instead of overlapping it.
+
+```typescript
+const renderer = await createCliRenderer({
+  screenMode: "split-footer",
+  footerHeight: 20,
+})
+
+// Change footer height at runtime
+renderer.footerHeight = 15
+```
+
+Split-footer bookkeeping lives in the native renderer. A shared `SplitScrollback` model tracks the rows it has already published and the current tail column, so the footer pins to the bottom of the terminal as scrollback grows. Captured stdout and [scrollback writers](#writing-to-scrollback) both produce styled `OptimizedBuffer` snapshots. The native side emits these as ANSI alongside the footer repaint in one atomic frame. The renderer flushes pending output before `resize`, `suspend`, mode transitions, and `destroy`.
+
+## External output mode
+
+The `externalOutputMode` option controls what happens to writes that go through the renderer's configured `stdout.write` while the renderer is active. It does not change `stderr`, and it is separate from the built-in console overlay.
+
+The native renderer still paints to the real TTY. `externalOutputMode` only changes the TypeScript-side `stdout.write` path.
+
+- **`"capture-stdout"`**: Intercepts `stdout.write`, queues the text, and flushes it above the footer during split-footer renders. Only valid when `screenMode` is `"split-footer"`.
+- **`"passthrough"`**: Leaves `stdout.write` untouched. Output goes directly to the terminal.
+
+The default depends on the screen mode: `"capture-stdout"` for split-footer, `"passthrough"` for everything else.
+
+```typescript
+// Captured stdout appears above the footer
+const renderer = await createCliRenderer({
+  screenMode: "split-footer",
+  externalOutputMode: "capture-stdout",
+})
+
+// Switch at runtime
+renderer.externalOutputMode = "passthrough"
+```
+
+## Console mode
+
+The `consoleMode` option controls the built-in console overlay (`TerminalConsole`).
+
+- **`"console-overlay"`** (default): Captures console output (console.log, console.error, etc.) and renders it in a toggleable panel within the TUI.
+- **`"disabled"`**: Hides and deactivates the overlay surface.
+
+Current caveat: `consoleMode` only changes the overlay surface.
+If you need plain `console.*` behavior, set `OTUI_USE_CONSOLE=false`.
+
+```typescript
+const renderer = await createCliRenderer({
+  screenMode: "split-footer",
+  externalOutputMode: "capture-stdout",
+  consoleMode: "disabled",
+})
+```
+
+## Writing to scrollback
+
+In split-footer mode with `externalOutputMode: "capture-stdout"`, the renderer also owns a programmatic append path above the footer. Use it when you want rich, styled output in scrollback instead of raw `console.log` text — colors, wrapping, syntax-highlighted code, and markdown. Every append goes through the same FIFO queue as captured stdout, so ordering stays deterministic even when both sources interleave.
+
+Both APIs require `screenMode: "split-footer"` and `externalOutputMode: "capture-stdout"`. They throw otherwise.
+
+### `renderer.writeToScrollback(writer)`
+
+Render a renderable tree into an off-screen buffer and commit it as one scrollback snapshot.
+
+```typescript
+import { TextRenderable } from "@opentui/core"
+
+renderer.writeToScrollback((ctx) => {
+  const root = new TextRenderable(ctx.renderContext, {
+    id: "api-response",
+    position: "absolute",
+    left: 0,
+    top: 0,
+    width: ctx.width,
+    height: 1,
+    content: "api responded in 12ms",
+    fg: "#8BD5CA",
+  })
+
+  return {
+    root,
+    width: ctx.width,
+    height: 1,
+    startOnNewLine: true,
+    trailingNewline: true,
+  }
+})
+```
+
+The writer receives a `ScrollbackRenderContext`:
+
+| Field           | Type            | Description                                             |
+| --------------- | --------------- | ------------------------------------------------------- |
+| `width`         | `number`        | Current renderer width                                  |
+| `widthMethod`   | `WidthMethod`   | Grapheme width method the renderer is using             |
+| `tailColumn`    | `number`        | Column where the previous scrollback commit ended       |
+| `renderContext` | `RenderContext` | Context you pass to new renderables inside the snapshot |
+
+And returns a `ScrollbackSnapshot`:
+
+| Field             | Type         | Description                                                                                  |
+| ----------------- | ------------ | -------------------------------------------------------------------------------------------- |
+| `root`            | `Renderable` | Top renderable that will be drawn into the snapshot buffer                                   |
+| `width`           | `number`     | Optional; defaults to the root's width, capped to renderer width                             |
+| `height`          | `number`     | Optional; defaults to the root's measured height                                             |
+| `rowColumns`      | `number`     | Optional explicit width for tail-column tracking (used for partial-row commits)              |
+| `startOnNewLine`  | `boolean`    | Insert a newline before this commit when the previous commit ended mid-row (default: `true`) |
+| `trailingNewline` | `boolean`    | Append a newline after the final row of this commit (default: `true`)                        |
+| `teardown`        | `() => void` | Optional cleanup hook invoked after the snapshot is rendered (e.g., dispose a Solid subtree) |
+
+Use `startOnNewLine: false` plus `trailingNewline: false` for inline output — for example, an icon prefix followed by streaming text.
+
+### `renderer.createScrollbackSurface(options?)`
+
+For streaming output that you want to render many times before committing (token-by-token code highlighting, markdown blocks settling as they parse), use a `ScrollbackSurface`. The surface renders into a backing buffer. You can re-render the tree in place and then commit specific row ranges to scrollback.
+
+```typescript
+const surface = renderer.createScrollbackSurface({ startOnNewLine: true })
+
+const code = new CodeRenderable(surface.renderContext, {
+  id: "streamed-code",
+  content: "",
+  filetype: "typescript",
+  syntaxStyle,
+  width: "100%",
+  streaming: true,
+  treeSitterClient,
+})
+surface.root.add(code)
+
+code.content = "const x = 1"
+await surface.settle() // waits for pending Tree-sitter highlighting
+
+// Commit the rows we've finished highlighting; the rest can keep re-rendering
+surface.commitRows(0, surface.height)
+
+// Later, when the stream is done:
+surface.destroy()
+```
+
+| Method                                      | Description                                                                      |
+| ------------------------------------------- | -------------------------------------------------------------------------------- |
+| `render()`                                  | Measure, lay out, and render the current tree into the backing buffer            |
+| `settle(timeoutMs?)`                        | Render, then wait for any in-flight Tree-sitter highlights before returning      |
+| `commitRows(start, endExclusive, options?)` | Copy a row range out of the backing buffer and enqueue it as a scrollback commit |
+| `destroy()`                                 | Tear down the surface and its backing buffer                                     |
+
+`commitRows` throws if you call it before `render()`, or if the renderer's width or `widthMethod` changed since the last `render()`. Re-render before committing fresh rows in either case.
+
+For React and Solid, use the binding-level helpers that wrap `writeToScrollback` with JSX support. See [`createScrollbackWriter` / `writeSolidToScrollback`](/docs/bindings/solid#scrollback-writers) in the Solid docs.
+
+## The root renderable
+
+Every renderer has a `root` property. It is a special `RootRenderable` at the top of the component tree:
+
+```typescript
+import { Box, Text } from "@opentui/core"
+
+// Add components to the root
+renderer.root.add(Box({ width: 40, height: 10, borderStyle: "rounded" }, Text({ content: "Hello, OpenTUI!" })))
+```
+
+The root renderable fills the entire terminal and adjusts when you resize it.
+
+## Render loop control
+
+You can use these control modes:
+
+### Automatic mode (default)
+
+If you do not call `start()`, the renderer re-renders only when the component tree changes:
+
+```typescript
+const renderer = await createCliRenderer()
+renderer.root.add(Text({ content: "Static content" })) // Triggers render
+```
+
+### Continuous mode
+
+Call `start()` to run the render loop continuously at the target FPS:
+
+```typescript
+renderer.start() // Start continuous rendering
+renderer.stop() // Stop the render loop
+```
+
+You can change the render loop cadence at runtime. `targetFps` sets the steady-state continuous render rate. `maxFps` caps how often `requestRender()` can produce an immediate extra frame:
+
+```typescript
+renderer.targetFps = 60
+renderer.maxFps = 120
+```
+
+### Live rendering
+
+For animations, call `requestLive()` to enable continuous rendering:
+
+```typescript
+// Request live mode (increments internal counter)
+renderer.requestLive()
+
+// When animation completes, drop the request
+renderer.dropLive()
+```
+
+Multiple components can request animations at the same time. The renderer stays live until all requests drop.
+
+### Pause and suspend
+
+```typescript
+renderer.pause() // Pause rendering (use start() or requestLive() to run it again)
+
+renderer.suspend() // Fully suspend (disables mouse, input, and raw mode)
+renderer.resume() // Resume from suspended state
+```
+
+By default, suspending or destroying clears the region OpenTUI owns on the main screen. If you want to keep that
+content visible after shutdown, set `clearOnShutdown: false`:
+
+```typescript
+const renderer = await createCliRenderer({
+  screenMode: "split-footer",
+  clearOnShutdown: false,
+})
+```
+
+## Key properties
+
+| Property                   | Type                           | Description                                                             |
+| -------------------------- | ------------------------------ | ----------------------------------------------------------------------- |
+| `root`                     | `RootRenderable`               | Root of the component tree                                              |
+| `width`                    | `number`                       | Current render width in columns                                         |
+| `height`                   | `number`                       | Current render height in rows                                           |
+| `console`                  | `TerminalConsole`              | Built-in console overlay                                                |
+| `keyInput`                 | `KeyHandler`                   | Keyboard input handler                                                  |
+| `isRunning`                | `boolean`                      | Whether the render loop is active                                       |
+| `isDestroyed`              | `boolean`                      | Whether the renderer has been destroyed                                 |
+| `currentFocusedRenderable` | `Renderable \| null`           | Currently focused component                                             |
+| `screenMode`               | `ScreenMode`                   | Active screen mode; assignable to swap between modes at runtime         |
+| `footerHeight`             | `number`                       | Split-footer height; assignable to resize the footer                    |
+| `externalOutputMode`       | `ExternalOutputMode`           | Active stdout routing; assignable to switch between capture/passthrough |
+| `consoleMode`              | `ConsoleMode`                  | Active console overlay mode                                             |
+| `themeMode`                | `ThemeMode \| null`            | Detected terminal theme (`"dark"` / `"light"`)                          |
+| `capabilities`             | `TerminalCapabilities \| null` | Detected terminal capabilities                                          |
+| `targetFps`                | `number`                       | Target render loop FPS; assignable at runtime                           |
+| `maxFps`                   | `number`                       | Upper cap for immediate re-renders; assignable at runtime               |
+
+## Events
+
+Use `renderer.on(event, callback)` to subscribe:
+
+| Event                 | Payload                           | Description                                                           |
+| --------------------- | --------------------------------- | --------------------------------------------------------------------- |
+| `resize`              | `(width: number, height: number)` | Terminal window resized                                               |
+| `focus`               | `()`                              | Terminal window gained focus                                          |
+| `blur`                | `()`                              | Terminal window lost focus                                            |
+| `theme_mode`          | `(mode: "dark" \| "light")`       | Terminal color scheme changed. See [Theme mode](#theme-mode) section. |
+| `palette`             | `(colors: TerminalColors)`        | Terminal palette was refreshed and changed                            |
+| `capabilities`        | `(caps: TerminalCapabilities)`    | Terminal capabilities detected                                        |
+| `selection`           | `(selection: Selection)`          | Text selection completed                                              |
+| `destroy`             | `()`                              | Renderer destroyed                                                    |
+| `memory:snapshot`     | `(snapshot: MemorySnapshot)`      | Memory usage snapshot available                                       |
+| `debugOverlay:toggle` | `(enabled: boolean)`              | Debug overlay visibility changed                                      |
+
+```typescript
+// Terminal resized
+renderer.on("resize", (width, height) => {
+  console.log(`Terminal size: ${width}x${height}`)
+})
+
+// Terminal focus events
+renderer.on("focus", () => {
+  console.log("Terminal gained focus")
+})
+
+renderer.on("blur", () => {
+  console.log("Terminal lost focus")
+})
+
+// Renderer destroyed
+renderer.on("destroy", () => {
+  console.log("Renderer destroyed")
+})
+
+// Text selection completed
+renderer.on("selection", (selection) => {
+  console.log("Selected text:", selection.getSelectedText())
+})
+```
+
+## Theme mode
+
+OpenTUI detects the terminal's preferred color scheme (dark or light) through two mechanisms:
+
+1. **DEC mode 2031** (`CSI ? 997 ; ... n`): terminals that support it report changes live.
+2. **OSC 10/11 fallback**: if the terminal does not support DEC 2031, OpenTUI inspects the terminal's foreground and background colors, then derives the mode from the background brightness.
+
+Read the current mode via `renderer.themeMode` (`"dark"`, `"light"`, or `null` before detection completes) and subscribe to the `theme_mode` event for later changes.
+
+```typescript
+import { type ThemeMode } from "@opentui/core"
+
+const mode = renderer.themeMode
+
+renderer.on("theme_mode", (nextMode: ThemeMode) => {
+  console.log("Theme mode changed:", nextMode)
+})
+```
+
+DEC 2031 always wins over the OSC fallback, so a terminal that starts without DEC support but gains it later still reports the correct mode.
+
+### `waitForThemeMode(timeoutMs?)`
+
+Use `waitForThemeMode` if you need to block briefly for theme detection at startup — for example, to pick a light or dark color palette before the first paint. It resolves with the detected mode, or `null` if the timeout elapses before either source reports.
+
+```typescript
+const mode = await renderer.waitForThemeMode(1000) // defaults to 1000 ms
+```
+
+Pass `0` to read the current mode synchronously without waiting.
+
+## Terminal integration
+
+These methods drive the terminal emulator directly, outside of the render buffer:
+
+### Terminal title and background
+
+```typescript
+renderer.setTerminalTitle("OpenTUI – editing notes.md")
+
+// Set the render buffer background. OpenTUI also emits OSC 11
+// so the terminal's own background matches.
+renderer.setBackgroundColor("#0D1117")
+
+// Reset terminal background to its theme default via OSC 111
+renderer.resetTerminalBgColor()
+```
+
+`destroy()` and `suspend()` call `resetTerminalBgColor()` for you. Call it yourself only for cases the renderer does not own — for example, before pausing with SIGTSTP.
+
+### OSC 52 clipboard
+
+OpenTUI can set and clear the terminal's clipboard via OSC 52. This works across SSH sessions and remote editors. Terminals that opt out silently ignore these calls.
+
+```typescript
+if (renderer.isOsc52Supported()) {
+  renderer.copyToClipboardOSC52("https://opentui.dev")
+  renderer.clearClipboardOSC52()
+}
+
+// Target specific clipboards
+renderer.copyToClipboardOSC52("primary", "primary")
+renderer.copyToClipboardOSC52("both", "clipboard-primary")
+```
+
+`ClipboardTarget` values are `"clipboard"`, `"primary"`, or `"clipboard-primary"`. Both methods return `false` if the renderer cannot write to stdout — for example, after you destroy it.
+
+### Notifications
+
+Trigger a terminal-mediated desktop notification:
+
+```typescript
+renderer.triggerNotification("Build finished", "OpenTUI")
+```
+
+The method returns `false` when no OSC notification protocol was detected. See [Notifications](/docs/core-concepts/notifications) for details.
+
+### Raw OSC sequences
+
+Subscribe to raw OSC sequences the terminal emits — palette queries, cursor position reports, custom escape codes. Use this when you integrate OpenTUI with a terminal feature that does not have a dedicated API yet.
+
+```typescript
+const unsubscribe = renderer.subscribeOsc((sequence) => {
+  // sequence is the full ESC ] ... BEL / ST payload
+})
+
+// later
+unsubscribe()
+```
+
+## Cursor control
+
+Use these methods to control the cursor position and style:
+
+```typescript
+// Position and visibility
+renderer.setCursorPosition(10, 5, true)
+
+// Cursor style
+//
+// Available styles: "default", "block", "underline", "line"
+// The default style is "default", which preserves the terminal's native cursor
+// style instead of overriding it.
+renderer.setCursorStyle({ style: "block", blinking: true }) // Blinking block
+renderer.setCursorStyle({ style: "underline", blinking: false }) // Steady underline
+renderer.setCursorStyle({ style: "line", blinking: true }) // Blinking line
+renderer.setCursorStyle({ style: "default" }) // Reset to terminal's native cursor
+
+// Cursor style with color
+renderer.setCursorStyle({
+  style: "block",
+  blinking: true,
+  color: RGBA.fromHex("#FF0000"),
+})
+
+// Cursor style with mouse pointer
+//
+// Types of mouse pointers available: "default", "pointer", "text", "crosshair", "move",
+// "not-allowed"
+renderer.setCursorStyle({
+  style: "block",
+  blinking: false,
+  cursor: "pointer",
+})
+```
+
+## Input handling
+
+Add custom input handlers:
+
+```typescript
+renderer.addInputHandler((sequence) => {
+  if (sequence === "\x1b[A") {
+    // Up arrow - handle and consume
+    return true
+  }
+  return false // Let other handlers process
+})
+```
+
+By default, `addInputHandler()` appends handlers to the chain and runs them after built-in handlers. Use `prependInputHandler()` to add a handler at the start of the chain and run it before built-in handlers.
+
+## Debug overlay
+
+Use the debug overlay to show FPS, memory usage, and other stats:
+
+```typescript
+renderer.toggleDebugOverlay()
+
+// You can also configure it
+import { DebugOverlayCorner } from "@opentui/core"
+
+renderer.configureDebugOverlay({
+  enabled: true,
+  corner: DebugOverlayCorner.topRight,
+})
+```
+
+## Cleanup
+
+Always destroy the renderer when you finish so you restore the terminal state:
+
+```typescript
+renderer.destroy()
+```
+
+Destroying the renderer restores the terminal to its original state, disables mouse tracking, and cleans up resources.
+
+**Important:** OpenTUI does not automatically clean up on `process.exit` or unhandled errors. This design gives you control. See [Lifecycle](/docs/core-concepts/lifecycle/) for signal handling options and best practices.
+
+## Environment variables
+
+See the [environment variable reference](/docs/reference/env-vars) for the full list.
+
+The renderer-specific ones you will most likely care about are:
+
+- `OTUI_USE_CONSOLE` controls global `console.*` capture.
+- `SHOW_CONSOLE` opens the built-in console overlay at startup.
+- `OTUI_NO_NATIVE_RENDER` skips the Zig/native frame renderer. In `"split-footer"` mode, the current stdout flush path can still write ANSI.
+- `OTUI_DUMP_CAPTURES` dumps captured stdout and console caches from the renderer exit handler.
diff --git a/.agents/skills/opentui/docs/getting-started.mdx b/.agents/skills/opentui/docs/getting-started.mdx
new file mode 100644
index 0000000..7f28bc6
--- /dev/null
+++ b/.agents/skills/opentui/docs/getting-started.mdx
@@ -0,0 +1,90 @@
+---
+title: Getting started
+description: Install OpenTUI and create your first terminal UI
+order: 1
+navTitle: Introduction
+skill:
+  entry: true
+  intents: [getting-started, installation, quickstart, intro]
+---
+
+# Getting started
+
+OpenTUI is a native terminal UI core written in Zig with TypeScript bindings. The native core exposes a C ABI and can be used from any language. OpenTUI powers OpenCode in production today and will also power terminal.shop. It is an extensible core with a focus on correctness, stability, and high performance. It provides a component-based architecture with flexible layout capabilities, allowing you to create complex terminal applications.
+
+## Installation
+
+OpenTUI is currently [Bun](https://bun.sh) exclusive but Deno and Node support in-progress.
+
+```bash
+mkdir my-tui && cd my-tui
+bun init -y
+bun add @opentui/core
+```
+
+## Hello world
+
+Create `index.ts`:
+
+```typescript
+import { createCliRenderer, Text } from "@opentui/core"
+
+const renderer = await createCliRenderer({
+  exitOnCtrlC: true,
+})
+
+renderer.root.add(
+  Text({
+    content: "Hello, OpenTUI!",
+    fg: "#00FF00",
+  }),
+)
+```
+
+Run it:
+
+```bash
+bun index.ts
+```
+
+You should see green text. Press `Ctrl+C` to exit.
+
+## Composing components
+
+Components nest naturally. Here's a bordered panel with content:
+
+```typescript
+import { createCliRenderer, Box, Text } from "@opentui/core"
+
+const renderer = await createCliRenderer({
+  exitOnCtrlC: true,
+})
+
+renderer.root.add(
+  Box(
+    { borderStyle: "rounded", padding: 1, flexDirection: "column", gap: 1 },
+    Text({ content: "Welcome", fg: "#FFFF00" }),
+    Text({ content: "Press Ctrl+C to exit" }),
+  ),
+)
+```
+
+`Box` and `Text` are factory functions. The first argument is props; additional arguments are children.
+
+## What's next
+
+### Core concepts
+
+- [Renderer](/docs/core-concepts/renderer) - The rendering engine
+- [Layout](/docs/core-concepts/layout) - Flexbox positioning
+- [Constructs](/docs/core-concepts/constructs) - The declarative component API
+
+### Components
+
+- [Text](/docs/components/text), [Box](/docs/components/box) - Display and layout
+- [Input](/docs/components/input), [Select](/docs/components/select) - User interaction
+
+### Framework bindings
+
+- [React](/docs/bindings/react)
+- [Solid.js](/docs/bindings/solid)
diff --git a/.agents/skills/opentui/docs/keymap/addons.mdx b/.agents/skills/opentui/docs/keymap/addons.mdx
new file mode 100644
index 0000000..7df5a3a
--- /dev/null
+++ b/.agents/skills/opentui/docs/keymap/addons.mdx
@@ -0,0 +1,213 @@
+---
+title: Built-in Addons
+description: Shipped universal and OpenTUI-specific keymap addons
+order: 6
+navTitle: Built-in Addons
+---
+
+# Built-in keymap addons
+
+`@opentui/keymap` keeps the engine bare. The built-in addon packages install parser stages, field compilers, diagnostics, disambiguation and host-specific helpers on top of the public registration APIs.
+
+If you want to build your own addon, see [Custom Addons](/docs/keymap/custom-addons).
+
+Every addon returns a disposer.
+
+```ts
+import * as addons from "@opentui/keymap/addons"
+import * as opentuiAddons from "@opentui/keymap/addons/opentui"
+```
+
+## Universal addons
+
+### Defaults
+
+| Export                                | Description                                           |
+| ------------------------------------- | ----------------------------------------------------- |
+| `defaultBindingParser`                | Shared parser for string key syntax                   |
+| `defaultEventMatchResolver`           | Shared event matcher for canonical normalized strokes |
+| `registerDefaultBindingParser()`      | Appends `defaultBindingParser`                        |
+| `registerDefaultEventMatchResolver()` | Appends `defaultEventMatchResolver`                   |
+| `registerDefaultKeys()`               | Installs both default stages together                 |
+
+The shared default parser accepts single-stroke named keys, modifier chords, literal punctuation, `" "` for space, `"+"` as a literal plus key, `<token>` aliases, and `{pattern}` runtime captures. It parses concatenated multi-stroke sequences such as `dd`, `<leader>s`, or `{count}j`.
+
+Recognized modifier prefixes (case-insensitive, joined with `+`):
+
+| Modifier | Aliases         |
+| -------- | --------------- |
+| `ctrl`   | `control`       |
+| `shift`  | -               |
+| `meta`   | `alt`, `option` |
+| `super`  | -               |
+| `hyper`  | -               |
+
+### Field addons
+
+| Export                       | Adds                                                                               |
+| ---------------------------- | ---------------------------------------------------------------------------------- |
+| `registerBindingOverrides()` | Layer-local `bindingOverrides` field for replacing bindings by string command name |
+| `registerEnabledFields()`    | Layer and command `enabled` fields                                                 |
+| `registerMetadataFields()`   | Binding `desc` / `group` and command `desc` / `title` / `category` metadata        |
+| `registerAliasesField()`     | Layer-local `aliases` field for remapping single-key binding names                 |
+
+`registerBindingOverrides()` expects `bindingOverrides` to already be a `Binding[]` array. It rewrites that layer's binding array once at registration time. Matching string commands are replaced by the override binding and unmatched bindings stay in place.
+
+`registerEnabledFields()` accepts `boolean`, `() => boolean`, or `ReactiveMatcher` values. It applies to layers and commands, not bindings. It controls activation only; it does not publish attrs.
+
+`registerMetadataFields()` validates and trims metadata fields before exposing them in projections. Binding `desc` / `group` become binding metadata. Command `desc` / `title` / `category` become command metadata in `commandAttrs`.
+
+Layer metadata is app-specific. Register layer fields directly with `registerLayerFields()` and call `ctx.attr(...)` when graph/debug visualizations need layer labels or grouping metadata.
+
+`registerAliasesField()` adds bindings instead of replacing the originals and aliases stay local to the layer that declared them.
+
+### Syntax and sequence addons
+
+| Export                                   | Description                                                             |
+| ---------------------------------------- | ----------------------------------------------------------------------- |
+| `registerCommaBindings()`                | Expands `x, y` into multiple bindings                                   |
+| `registerEmacsBindings()`                | Parses Emacs-style spaced chords such as `ctrl+x ctrl+s`                |
+| `registerLeader()`                       | Defines a token such as `leader` that `<leader>` syntax expands through |
+| `registerModBindings()`                  | Adds platform-aware `mod+...` bindings using host metadata              |
+| `registerTimedLeader()`                  | Defines a leader token and clears it after a timeout                    |
+| `registerBackspacePopsPendingSequence()` | Lets Backspace step back through the current pending sequence           |
+| `registerEscapeClearsPendingSequence()`  | Lets Escape cancel the current pending sequence                         |
+| `registerNeovimDisambiguation()`         | Timeout-based exact-vs-prefix disambiguation                            |
+
+Options:
+
+| API                                      | Options                                                                              |
+| ---------------------------------------- | ------------------------------------------------------------------------------------ |
+| `registerLeader()`                       | `LeaderOptions`: `trigger`, optional semantic `name` (default `"leader"`)            |
+| `registerTimedLeader()`                  | `TimedLeaderOptions`: `LeaderOptions` plus `timeoutMs`, `onArm`, `onDisarm`          |
+| `registerBackspacePopsPendingSequence()` | `BackspacePopsPendingSequenceOptions`: `preventDefault` (default `true`), `priority` |
+| `registerEscapeClearsPendingSequence()`  | `EscapeClearsPendingSequenceOptions`: `preventDefault` (default `true`), `priority`  |
+| `registerNeovimDisambiguation()`         | `NeovimDisambiguationOptions`: `timeoutMs` (default `300`)                           |
+
+Register disambiguation addons before registering same-layer exact/prefix bindings such as `g` and `gg`.
+
+Leader `trigger` accepts a key string, key object, binding-like `{ key }`, or a single binding lookup result from `createBindingLookup().get(...)`.
+
+### Diagnostics
+
+| Export                                | Description                                                       |
+| ------------------------------------- | ----------------------------------------------------------------- |
+| `registerDeadBindingWarnings()`       | Warns when a binding has no command and no reachable continuation |
+| `registerUnresolvedCommandWarnings()` | Warns when a string command cannot be resolved                    |
+
+## Ex commands
+
+`registerExCommands()` installs ex-command field compilers, a command transformer and a resolver for `:name ...args` strings. Register ex commands through normal keymap layers by using a colon-prefixed command name or `namespace: "excommands"`.
+
+```ts
+import { registerExCommands } from "@opentui/keymap/addons"
+
+registerExCommands(keymap)
+
+keymap.registerLayer({
+  commands: [
+    {
+      name: "write",
+      namespace: "excommands",
+      aliases: ["w"],
+      nargs: "1",
+      desc: "Write file",
+      run({ payload }) {
+        // payload.raw === ":write session.log"
+        // payload.args === ["session.log"]
+      },
+    },
+  ],
+})
+```
+
+`ExCommand` fields:
+
+| Field        | Type                                                                        | Required | Description                                                      |
+| ------------ | --------------------------------------------------------------------------- | -------- | ---------------------------------------------------------------- |
+| `name`       | `string`                                                                    | yes      | Command name. `:name` and `name` both normalize to `:name`       |
+| `aliases`    | `string[]`                                                                  | no       | Additional names                                                 |
+| `nargs`      | `"0"`, `"1"`, `"?"`, `"*"`, `"+"`                                           | no       | Argument-count validation                                        |
+| `run`        | `(ctx: CommandContext<TTarget, TEvent, ExCommandPayload>) => CommandResult` | yes      | `ctx.payload` contains the trimmed `raw` input and parsed `args` |
+| extra fields | `unknown`                                                                   | no       | Added as top-level fields on the registered command              |
+
+- Registered ex commands default `namespace` to `excommands`.
+- Aliases produce additional registered commands, for example `:write` and `:w`.
+- Extra fields are preserved on `getCommands()` / `getCommandEntries()` results and compiled through command-field addons.
+- `runCommand(":write file.txt")` and `dispatchCommand(":write file.txt")` both go through the installed resolver.
+
+## OpenTUI addons
+
+`@opentui/keymap/addons/opentui` re-exports every universal addon and adds the OpenTUI-specific helpers below.
+
+### `registerBaseLayoutFallback()`
+
+Adds an event match resolver that falls back to `KeyEvent.baseCode` so bindings can ignore active keyboard layout changes when Kitty base-layout reporting is available. Direct stroke matches win before base-layout fallback matches, even across active layers.
+
+### Edit buffer helpers
+
+| Export                                | Description                                                                              |
+| ------------------------------------- | ---------------------------------------------------------------------------------------- |
+| `createTextareaBindings()`            | Returns generated textarea bindings with overrides prepended                             |
+| `registerEditBufferCommands()`        | Registers the shared edit-buffer command set against `renderer.currentFocusedEditor`     |
+| `registerTextareaMappingSuspension()` | Suspends focused `TextareaRenderable` mapped shortcuts while keeping plain typing intact |
+| `registerManagedTextareaLayer()`      | High-level textarea integration: commands, suspension, default bindings and overrides    |
+
+`registerManagedTextareaLayer()` accepts a global `Layer` shape plus optional `bindings`, but it intentionally excludes `target` and `targetMode`. The helper is global and follows `renderer.currentFocusedEditor`.
+
+`EditBufferCommandOptions`:
+
+| Field              | Type                                             | Description                                                                     |
+| ------------------ | ------------------------------------------------ | ------------------------------------------------------------------------------- |
+| `category`         | `string`                                         | Override generated command category, defaulting to `Text Editing`               |
+| `group`            | `string`                                         | Override generated binding group, defaulting to `Text Editing`                  |
+| `includeFineGroup` | `boolean`                                        | Include hard-coded binding `fineGroup` fields for apps that register that field |
+| `commandNames`     | `Partial<Record<EditBufferCommandName, string>>` | Override generated command names                                                |
+| `descriptions`     | `Partial<Record<EditBufferCommandName, string>>` | Override generated command descriptions                                         |
+
+`registerEditBufferCommands()` and `registerTextareaMappingSuspension()` are reference-counted per keymap, so multiple integrations can safely share them.
+
+### `EditBufferCommandName`
+
+| Action                    | Default command                 | Default description         |
+| ------------------------- | ------------------------------- | --------------------------- |
+| `move-left`               | `input.move.left`               | Cursor left                 |
+| `move-right`              | `input.move.right`              | Cursor right                |
+| `move-up`                 | `input.move.up`                 | Cursor up                   |
+| `move-down`               | `input.move.down`               | Cursor down                 |
+| `select-left`             | `input.select.left`             | Select left                 |
+| `select-right`            | `input.select.right`            | Select right                |
+| `select-up`               | `input.select.up`               | Select up                   |
+| `select-down`             | `input.select.down`             | Select down                 |
+| `line-home`               | `input.line.home`               | Line start                  |
+| `line-end`                | `input.line.end`                | Line end                    |
+| `select-line-home`        | `input.select.line.home`        | Select to line start        |
+| `select-line-end`         | `input.select.line.end`         | Select to line end          |
+| `visual-line-home`        | `input.visual.line.home`        | Visual line start           |
+| `visual-line-end`         | `input.visual.line.end`         | Visual line end             |
+| `select-visual-line-home` | `input.select.visual.line.home` | Select to visual line start |
+| `select-visual-line-end`  | `input.select.visual.line.end`  | Select to visual line end   |
+| `buffer-home`             | `input.buffer.home`             | Buffer start                |
+| `buffer-end`              | `input.buffer.end`              | Buffer end                  |
+| `select-buffer-home`      | `input.select.buffer.home`      | Select to buffer start      |
+| `select-buffer-end`       | `input.select.buffer.end`       | Select to buffer end        |
+| `delete-line`             | `input.delete.line`             | Delete line                 |
+| `delete-to-line-end`      | `input.delete.to.line.end`      | Delete to line end          |
+| `delete-to-line-start`    | `input.delete.to.line.start`    | Delete to line start        |
+| `backspace`               | `input.backspace`               | Delete backward             |
+| `delete`                  | `input.delete`                  | Delete forward              |
+| `newline`                 | `input.newline`                 | New line                    |
+| `undo`                    | `input.undo`                    | Undo                        |
+| `redo`                    | `input.redo`                    | Redo                        |
+| `word-forward`            | `input.word.forward`            | Next word                   |
+| `word-backward`           | `input.word.backward`           | Previous word               |
+| `select-word-forward`     | `input.select.word.forward`     | Select next word            |
+| `select-word-backward`    | `input.select.word.backward`    | Select previous word        |
+| `delete-word-forward`     | `input.delete.word.forward`     | Delete next word            |
+| `delete-word-backward`    | `input.delete.word.backward`    | Delete previous word        |
+| `select-all`              | `input.select.all`              | Select all                  |
+| `submit`                  | `input.submit`                  | Submit                      |
+
+The generated textarea bindings come from the shared `defaultTextareaKeyBindings` in `@opentui/core`. `createTextareaBindings()` prepends overrides before those defaults so custom bindings win by order.
+
+See [Custom Addons](/docs/keymap/custom-addons) for the public addon-authoring APIs, lifecycle rules, callback contexts and extension-point quirks.
diff --git a/.agents/skills/opentui/docs/keymap/core.mdx b/.agents/skills/opentui/docs/keymap/core.mdx
new file mode 100644
index 0000000..77efb29
--- /dev/null
+++ b/.agents/skills/opentui/docs/keymap/core.mdx
@@ -0,0 +1,566 @@
+---
+title: Core
+description: Bare keymap engine and host contract
+order: 3
+---
+
+# Core keymap
+
+This page covers `@opentui/keymap` without any host-specific adapter.
+
+Use the bare engine when you want a custom host or when you want to build addons on top of the shared registration surface. If you want a ready-made host or need the host contract, start with [Hosts](/docs/keymap/hosts).
+
+## Construct a keymap
+
+```ts
+import { Keymap, type KeymapHost } from "@opentui/keymap"
+
+const keymap = new Keymap(host as KeymapHost<object>)
+```
+
+Bare keymaps do not parse string bindings until you install binding parsers and event match resolvers. In practice that usually means `registerDefaultKeys()` or one of the default host helpers.
+
+## `KeymapHost`
+
+`KeymapHost` is the contract that built-in hosts and custom adapters implement. See [Hosts](/docs/keymap/hosts) for the built-in OpenTUI and HTML adapters.
+
+| Member                        | Required | Description                                                                                                      |
+| ----------------------------- | -------- | ---------------------------------------------------------------------------------------------------------------- |
+| `metadata`                    | yes      | Platform, primary shortcut modifier and modifier capability metadata                                             |
+| `rootTarget`                  | yes      | Root target for the host hierarchy                                                                               |
+| `isDestroyed`                 | yes      | Host lifetime flag                                                                                               |
+| `getFocusedTarget()`          | yes      | Returns the currently focused target or `null`                                                                   |
+| `getParentTarget(target)`     | yes      | Parent traversal used for `focus-within` matching                                                                |
+| `isTargetDestroyed(target)`   | yes      | Target liveness check                                                                                            |
+| `onKeyPress(listener)`        | yes      | Subscribe to press events                                                                                        |
+| `onKeyRelease(listener)`      | yes      | Subscribe to release events                                                                                      |
+| `onFocusChange(listener)`     | yes      | Subscribe to focus changes                                                                                       |
+| `onTargetDestroy(target, fn)` | yes      | Subscribe to target disposal/removal                                                                             |
+| `createCommandEvent()`        | yes      | Creates the synthetic event used by `runCommand()` and `dispatchCommand()`                                       |
+| `onDestroy(listener)`         | no       | Optional host-destroy notification                                                                               |
+| `onRawInput(listener)`        | no       | Optional raw input hook, used before host key parsing. The listener returns `true` when it consumed the sequence |
+
+Host key events must satisfy `KeymapEvent`:
+
+| Member                    | Description                                                                                     |
+| ------------------------- | ----------------------------------------------------------------------------------------------- |
+| `name`                    | Normalized key name                                                                             |
+| `ctrl` / `shift` / `meta` | Modifier state                                                                                  |
+| `super` / `hyper`         | Optional extra modifier state                                                                   |
+| `preventDefault()`        | Prevents the matched event from reaching the host target                                        |
+| `stopPropagation()`       | Stops later keymap/host listeners from seeing the event and sets `propagationStopped` to `true` |
+| `propagationStopped`      | `true` after `stopPropagation()` was called                                                     |
+
+## Layers
+
+```ts
+keymap.registerLayer({
+  commands: [
+    { name: "save-file", title: "Save File", run() {} },
+    { name: "quit", run() {} },
+  ],
+})
+
+keymap.registerLayer({
+  target: editor,
+  targetMode: "focus-within",
+  priority: 10,
+  bindings: [
+    { key: "ctrl+s", cmd: "save-file", desc: "Save file" },
+    { key: "q", cmd: "quit", preventDefault: false },
+  ],
+})
+```
+
+| Field        | Description                                                                          |
+| ------------ | ------------------------------------------------------------------------------------ |
+| `target`     | Optional local target. Omit it for a global layer                                    |
+| `targetMode` | `"focus-within"` or `"focus"`. Defaults to `"focus-within"` when `target` is present |
+| `priority`   | Higher numbers win. Within the same priority, newer layers win                       |
+| `bindings`   | `Binding[]`                                                                          |
+| `commands`   | Named command definitions registered with the same layer                             |
+| extra fields | Custom fields used by registered layer-field compilers and binding pipeline addons   |
+
+- Targetless layers are always active.
+- Active layers all use the same precedence rules: higher `priority` wins, then newer layers win.
+- Returning `false` from a command rejects that candidate so lower-precedence handlers can continue.
+- `fallthrough` and `preventDefault` are independent. `fallthrough` continues inside the keymap; `preventDefault` controls whether the event escapes to the host.
+
+## Bindings
+
+| Form            | Example                              | Notes                                         |
+| --------------- | ------------------------------------ | --------------------------------------------- |
+| String stroke   | `"x"`, `"ctrl+x"`, `"enter"`         | Requires a registered binding parser          |
+| String sequence | `"dd"`, `"<leader>s"`, `"{count}j"`  | Concatenated multi-stroke sequence            |
+| Object stroke   | `{ name: "return", ctrl: true }`     | Skips string parsing and normalizes directly  |
+| Release binding | `{ key: "a", event: "release", ...}` | Release bindings support a single stroke only |
+
+The core engine only accepts full `Binding[]` arrays. If you want command-to-key config sugar, use `commandBindings(map)` from `@opentui/keymap/extras` to build the array before calling `registerLayer()`.
+
+`Binding` reserves `key`, `cmd`, `event`, `preventDefault` and `fallthrough`. All other fields are available to binding-field compilers.
+
+Use `attr(...)` in a binding-field compiler when a custom binding field should appear in query metadata such as `ActiveBinding.attrs` or `ActiveKey.bindingAttrs`.
+
+`Binding` field defaults:
+
+| Field            | Default   | Description                                                                                  |
+| ---------------- | --------- | -------------------------------------------------------------------------------------------- |
+| `event`          | `"press"` | Use `"release"` for single-stroke release bindings                                           |
+| `preventDefault` | `true`    | Calls `event.preventDefault()` and `event.stopPropagation()` after a match                   |
+| `fallthrough`    | `false`   | When `true`, later matching bindings in the same dispatch chain still run after this command |
+
+Release bindings dispatch on key release, but they do not appear in `getActiveKeys()` because active-key discovery is based on press/pending-sequence state.
+
+The shared default parser understands single-stroke named keys, modifier chords, literal punctuation, `" "` for space, `"+"` as a literal plus key, `<token>` aliases, and `{pattern}` runtime captures. Spaced Emacs-style sequences such as `ctrl+x ctrl+s` are not part of the default parser.
+
+Token and pattern registration names are syntax-free. The default parser maps `<leader>` to the token named `"leader"` and `{count}` to the sequence pattern named `"count"`. Parser-preserved display keeps the original syntax for UIs, while the engine stores semantic names.
+
+Sequence patterns can capture repeated runtime input and pass finalized values to command payloads:
+
+| Pattern field | Description                                                                                  |
+| ------------- | -------------------------------------------------------------------------------------------- |
+| `name`        | Semantic pattern name, also the default command payload key                                  |
+| `display`     | Optional parser-facing display override for structural graph/help UI                         |
+| `payloadKey`  | Optional override when the command payload field should differ from `name`                   |
+| `min` / `max` | Optional capture limits. Defaults to at least one input and no practical maximum             |
+| `match`       | Runtime event predicate that returns a captured value/display or `undefined` for no match    |
+| `finalize`    | Optional conversion from captured values to the final payload value, e.g. digits to a number |
+
+Patterns with the default unbounded `max` must be followed by a concrete continuation, such as `{count}j`; terminal unbounded patterns are rejected.
+
+## State and discovery
+
+| Method                     | Description                                                                                                                      |
+| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `setData(name, value)`     | Write runtime data                                                                                                               |
+| `getData(name)`            | Read runtime data                                                                                                                |
+| `hasPendingSequence()`     | `true` when a multi-stroke prefix is active                                                                                      |
+| `getPendingSequence()`     | Current pending sequence as `KeySequencePart[]`                                                                                  |
+| `clearPendingSequence()`   | Clears the pending sequence                                                                                                      |
+| `popPendingSequence()`     | Removes the last pending stroke. Returns `true` when a stroke was removed                                                        |
+| `getActiveKeys(options?)`  | Returns the currently reachable keys for the current focus and pending state                                                     |
+| `parseKeySequence(key)`    | Parses a `KeyLike` with the current parser/token/pattern environment                                                             |
+| `formatKey(key, options?)` | Parses and stringifies a `KeyLike` with the current environment                                                                  |
+| `createKeyMatcher(key)`    | Parses one `KeyLike` and returns a single-stroke predicate for any `KeyStringifyInput`. It does not match multi-stroke sequences |
+| `getHostMetadata()`        | Returns the host metadata used by addons such as `registerModBindings()`                                                         |
+
+`getActiveKeys()` accepts `ActiveKeyOptions`:
+
+| Option            | Default | Description                                                        |
+| ----------------- | ------- | ------------------------------------------------------------------ |
+| `includeBindings` | `false` | Include per-key `bindings` arrays with full binding views          |
+| `includeMetadata` | `false` | Include top-level `bindingAttrs` and `commandAttrs` on active keys |
+
+`ActiveKey` shape:
+
+| Field          | Type                    | Description                                                                                |
+| -------------- | ----------------------- | ------------------------------------------------------------------------------------------ |
+| `stroke`       | `NormalizedKeyStroke`   | Normalized stroke (name plus modifier flags)                                               |
+| `display`      | `string`                | Display string for the stroke, including the preserved token form when one was used        |
+| `tokenName`    | `string?`               | Token name when this key resolved through a registered token such as `leader`              |
+| `continues`    | `boolean`               | `true` when at least one binding continues the sequence past this key                      |
+| `command`      | `BindingCommand?`       | Command at this exact sequence, if any                                                     |
+| `bindings`     | `ActiveBinding[]?`      | Per-key bindings; populated only when `includeBindings: true`                              |
+| `bindingAttrs` | `Readonly<Attributes>?` | Compiled binding attrs for the chosen binding; populated only when `includeMetadata: true` |
+| `commandAttrs` | `Readonly<Attributes>?` | Compiled command attrs for the chosen binding; populated only when `includeMetadata: true` |
+
+`ActiveBinding` shape:
+
+| Field            | Type                    | Description                                            |
+| ---------------- | ----------------------- | ------------------------------------------------------ |
+| `sequence`       | `KeySequencePart[]`     | Full key sequence that triggers the binding            |
+| `event`          | `"press" \| "release"`  | Event the binding fires on                             |
+| `preventDefault` | `boolean`               | Resolved `preventDefault` after applying the default   |
+| `fallthrough`    | `boolean`               | Resolved `fallthrough` after applying the default      |
+| `command`        | `BindingCommand?`       | Command name or inline handler attached to the binding |
+| `attrs`          | `Readonly<Attributes>?` | Compiled binding-field attrs                           |
+| `commandAttrs`   | `Readonly<Attributes>?` | Compiled command-field attrs for the bound command     |
+
+## Field and metadata model
+
+Custom fields are raw config. Compiled metadata is published by field compilers with `attr(...)`.
+
+| Surface | Custom fields                                                          | Metadata output                                 |
+| ------- | ---------------------------------------------------------------------- | ----------------------------------------------- |
+| Layer   | Extra layer properties feed layer-field compilers and binding pipeline | `GraphLayer.attrs` in graph snapshots           |
+| Binding | Extra binding properties feed binding-field compilers                  | `ActiveBinding.attrs`, `ActiveKey.bindingAttrs` |
+| Command | Extra command properties feed command-field compilers                  | `commandAttrs` on active keys and bindings      |
+
+Field compilers can validate and normalize values before publishing attrs. They can also keep behavior-only fields out of public metadata.
+
+```ts
+keymap.registerLayerFields({
+  name(value, ctx) {
+    ctx.attr("name", String(value).trim())
+  },
+})
+
+keymap.registerCommandFields({
+  enabled(value, ctx) {
+    ctx.activeWhen(() => value === true)
+  },
+  title(value, ctx) {
+    ctx.attr("title", String(value).trim())
+  },
+})
+```
+
+In that example, layer `name` exposes metadata for graph/debug UIs. Command `enabled` controls availability but exposes no metadata, while command `title` exposes normalized metadata for command palettes and help UIs.
+
+Use `stringifyKeyStroke()` or `stringifyKeySequence()` for display. Canonical formatting renders `return` as `enter`; `preferDisplay: true` keeps preserved token displays such as `<leader>`. Both are exported from `@opentui/keymap`:
+
+```ts
+import { stringifyKeyStroke, stringifyKeySequence } from "@opentui/keymap"
+```
+
+## Commands and queries
+
+Commands reserve only `name` and `run`. Other top-level properties are custom command fields.
+
+```ts
+keymap.registerLayer({
+  commands: [
+    {
+      name: "save-file",
+      namespace: "file",
+      title: "Save File",
+      run() {},
+    },
+  ],
+})
+
+// getCommands()[0] is the same command object:
+// { name: "save-file", namespace: "file", title: "Save File", run }
+```
+
+Command field compilers can publish metadata, add requirements or attach runtime matchers. Unknown command fields stay on the command object; they do not warn just because no compiler is registered.
+
+Return `{ ok: false, reason: "invalid-args" }` from `run()` when a command wants to reject with a specific programmatic result.
+
+Command queries search and filter across top-level command fields and compiled command metadata. The `namespace` shortcut reads the top-level `namespace` field.
+
+### Execution
+
+| Method                           | Description                                                                     |
+| -------------------------------- | ------------------------------------------------------------------------------- |
+| `runCommand(cmd, options?)`      | Runs a command against the registered command chain plus command resolvers      |
+| `dispatchCommand(cmd, options?)` | Runs a command through the active dispatch chain for the supplied/current focus |
+
+Pure extra exported from `@opentui/keymap/extras`:
+
+| Helper                           | Description                                                                                       |
+| -------------------------------- | ------------------------------------------------------------------------------------------------- |
+| `commandBindings(map)`           | Converts a command-to-key object map into `Binding[]`, trimming command keys before emitting them |
+| `createBindingLookup(config)`    | Resolves flat command config into command lookups and lazy cached gathered binding groups         |
+| `formatKeySequence(parts, opts)` | Formats parsed key sequences with optional token, key-name and modifier aliases                   |
+| `formatCommandBindings(...)`     | Formats command binding lists, reusing `formatKeySequence()` and deduping by default              |
+
+`commandBindings()` accepts optional `onWarning` and `onError` callbacks. `onWarning` reports trimmed-command overrides such as `" save-file "` and `"save-file"`; invalid key values are skipped by default, and `onError` lets callers observe them or throw if they want strict behavior.
+
+`formatKeySequence()` and `formatCommandBindings()` are stateless display helpers for parsed keymap data. They do not read runtime state or host config. Use `tokenDisplay`, `keyNameAliases` and `modifierAliases` when your app wants presentation-specific labels such as `"alt"` instead of `"meta"` or `"pgup"` instead of `"pageup"`.
+
+Example:
+
+```ts
+import { commandBindings } from "@opentui/keymap/extras"
+
+const bindings = commandBindings({
+  "  save-file  ": "ctrl+s",
+  ":write session.log": "<leader>s",
+})
+
+// => [
+//      { key: "ctrl+s", cmd: "save-file" },
+//      { key: "<leader>s", cmd: ":write session.log" },
+//    ]
+
+keymap.registerLayer({ bindings })
+```
+
+```ts
+import { formatCommandBindings, formatKeySequence } from "@opentui/keymap/extras"
+
+formatKeySequence(keymap.parseKeySequence("<leader>s"), {
+  tokenDisplay: { leader: "space" },
+  modifierAliases: { meta: "alt" },
+  keyNameAliases: { pageup: "pgup", pagedown: "pgdn", delete: "del" },
+})
+
+formatCommandBindings(keymap.getCommandBindings({ visibility: "registered", commands: ["save-file"] }).get("save-file"))
+```
+
+`createBindingLookup()` is an opinionated config-to-keymap transformation for flat command config. Keys are command names and become `binding.cmd`. Values can be `false`, `"none"`, a key, a full binding object, or arrays of keys/binding objects. `false`, `"none"`, and empty arrays emit no bindings.
+
+It deliberately keeps command identity separate from UI/layer grouping. Which bindings a component needs is a use-site concern, not part of the command name, so components gather named binding groups from plain command names when registering layers.
+
+Use `commandMap` when user-facing config names should differ from internal command names. Mapping happens when the lookup is created or updated; runtime lookups use internal command names.
+
+```ts
+import { createBindingLookup } from "@opentui/keymap/extras"
+
+const bindings = createBindingLookup(
+  {
+    show_palette: "ctrl+p",
+    exit_app: ["ctrl+c", "<leader>q"],
+    debug_app: "none",
+    paste_prompt: { key: "ctrl+v", preventDefault: false },
+    prompt_history_previous: "up",
+    prompt_history_next: "down",
+  },
+  {
+    bindingDefaults({ binding }) {
+      if (binding.group !== undefined) return
+      return { group: "App" }
+    },
+    commandMap: {
+      show_palette: "app.palette.show",
+      exit_app: "app.exit",
+    },
+  },
+)
+
+keymap.registerLayer({ bindings: bindings.gather("app", ["app.palette.show", "app.exit"]) })
+bindings.get("app.exit")
+bindings.has("app.exit")
+bindings.pick("app", ["app.exit"])
+bindings.omit("app", ["app.palette.show"])
+bindings.invalidate("app")
+```
+
+The lookup exposes these views:
+
+| API                      | Description                                                                                              |
+| ------------------------ | -------------------------------------------------------------------------------------------------------- |
+| `bindings`               | All enabled bindings, preserving config order                                                            |
+| `get(command)`           | Bindings for one exact command name, or an empty array when the command is missing/disabled              |
+| `has(command)`           | Whether the exact internal command has enabled bindings                                                  |
+| `gather(name, commands)` | Builds and caches a named binding group on first use; later calls with the same name return the cache    |
+| `pick(name, commands)`   | Bindings from an existing gathered group in caller command order; missing groups or commands are skipped |
+| `omit(name, commands)`   | All gathered bindings except matching string-command bindings, preserving group order                    |
+| `invalidate(name?)`      | Clears one gathered group, or all gathered groups when `name` is omitted                                 |
+| `update(config?)`        | Rebuilds command lookups from new or current config and clears gathered groups                           |
+
+Use `bindingDefaults` to add app-level fields to every emitted binding without mutating the original config. Defaults are spread before the resolved binding, so explicit binding fields win. Command names are exact and are not trimmed. `get()`, `gather()`, `pick()` and `omit()` return cached binding arrays directly when possible instead of defensive copies.
+
+Tokens such as `leader` are still registered through the normal keymap token APIs and referenced by parser syntax such as `<leader>`.
+
+`dispatchCommand()` respects current activation and can return `inactive` or `disabled` when the command exists but is not currently dispatchable. `runCommand()` walks the registered chain directly, so it can execute command-only layers programmatically even when they do not have an active binding.
+
+`RunCommandResult` is `{ ok: true, command? }` on success or `{ ok: false, reason, command? }` on failure. Reject reasons:
+
+| Reason         | Meaning                                                                                               |
+| -------------- | ----------------------------------------------------------------------------------------------------- |
+| `not-found`    | No registered command, resolver, or chain entry matched the supplied name                             |
+| `inactive`     | The command exists but no candidate is active for the supplied/current focus (`dispatchCommand` only) |
+| `disabled`     | All active candidates are gated off by `enabled` or other command-field matchers                      |
+| `invalid-args` | A resolver-provided rejection such as Ex-command argument validation                                  |
+| `rejected`     | Every candidate's handler returned synchronous `false`                                                |
+| `error`        | A resolver, runtime matcher, or handler threw synchronously                                           |
+
+`command` is included on rejected results when `includeCommand: true` is set and the keymap could resolve a command for the name.
+
+Command handlers may be sync or async. A synchronous `false` rejects the candidate and lets lower-precedence handlers continue. A handler may also return an explicit `RunCommandResult`, such as `{ ok: false, reason: "invalid-args" }`. A returned promise is treated as handled immediately; async rejection is reported through the `error` diagnostic event.
+
+`RunCommandOptions`:
+
+| Option           | Description                                                                      |
+| ---------------- | -------------------------------------------------------------------------------- |
+| `event`          | Event object passed into the command. Defaults to `host.createCommandEvent()`    |
+| `focused`        | Focus context used for active-layer resolution                                   |
+| `target`         | Explicit `ctx.target` override                                                   |
+| `includeCommand` | When `true`, successful and rejected results include the resolved command object |
+| `payload`        | Per-invocation payload exposed as `ctx.payload`                                  |
+
+### Queries
+
+| Method                      | Description                                                                    |
+| --------------------------- | ------------------------------------------------------------------------------ |
+| `getCommands(query?)`       | Returns command objects                                                        |
+| `getCommandEntries(query?)` | Returns command objects plus bindings for command discovery UIs                |
+| `getCommandBindings(query)` | Returns bindings grouped by requested command name for known-command label UIs |
+
+`CommandQuery` fields:
+
+| Field        | Description                                                    |
+| ------------ | -------------------------------------------------------------- |
+| `visibility` | `"reachable"` (default), `"active"`, or `"registered"`         |
+| `focused`    | Override the focus context used by the query                   |
+| `namespace`  | Filter by one or more namespace values                         |
+| `search`     | Text search over command names by default                      |
+| `searchIn`   | Additional command fields or compiled metadata to search       |
+| `filter`     | Object or predicate filter against command fields and metadata |
+
+- `reachable` dedupes by command name using the current dispatch winner.
+- `active` keeps every active candidate in precedence order, including same-name duplicates.
+- `registered` ignores focus and returns all registered commands.
+
+Use `getCommandEntries()` for command palettes, searchable help screens and other discovery surfaces that need commands plus their bindings. It runs the full `CommandQuery` and attaches matching bindings, so it is the heavier query.
+
+Use `getCommandBindings()` when a UI already knows the commands it wants to label and only needs their bindings:
+
+```ts
+const bindingsByCommand = keymap.getCommandBindings({
+  visibility: "registered",
+  commands: ["file.save", "app.quit"],
+})
+
+const saveBindings = bindingsByCommand.get("file.save") ?? []
+```
+
+The returned map preserves the requested command order and includes every requested command with `[]` when no matching bindings exist. Formatting remains app-owned; each returned `ActiveBinding` includes its parsed `sequence`.
+
+`CommandBindingsQuery` fields:
+
+| Field        | Description                                            |
+| ------------ | ------------------------------------------------------ |
+| `commands`   | Command names to include as map keys                   |
+| `visibility` | `"reachable"` (default), `"active"`, or `"registered"` |
+| `focused`    | Override the focus context used by the query           |
+
+## Graph snapshots
+
+`getGraphSnapshot(keymap, options?)` from `@opentui/keymap/extras/graph` returns a diagnostic projection for graph visualizers and debug UIs. It includes layers, commands, bindings, sequence nodes, active keys and the current pending sequence.
+
+Layer custom fields remain available as raw `GraphLayer.fields`; compiled layer metadata published with `ctx.attr(...)` appears as `GraphLayer.attrs`. Use attrs for stable visualization metadata such as layer display names.
+
+```ts
+import { getGraphSnapshot } from "@opentui/keymap/extras/graph"
+
+keymap.registerLayerFields({
+  name(value, ctx) {
+    ctx.attr("name", String(value).trim())
+  },
+})
+
+keymap.registerLayer({
+  name: "Global",
+  bindings: [{ key: "?", cmd: "toggle-help" }],
+})
+
+const snapshot = getGraphSnapshot(keymap)
+snapshot.layers[0]?.attrs?.name // "Global"
+```
+
+## Events and intercepts
+
+`keymap.on(...)`:
+
+| Event name        | Payload             | Description                                           |
+| ----------------- | ------------------- | ----------------------------------------------------- |
+| `state`           | `void`              | Batched "derived state may have changed" signal       |
+| `pendingSequence` | `KeySequencePart[]` | Synchronous pending-sequence updates, including clear |
+| `dispatch`        | `DispatchEvent`     | Sequence and binding execution trace events           |
+| `warning`         | `WarningEvent`      | Validation or analyzer warning                        |
+| `error`           | `ErrorEvent`        | Registration, query, resolver, or listener error      |
+
+`DispatchEvent` exposes `phase`, `event`, `focused`, `sequence` and optional `layer`, `binding` and `command`. Phases are `sequence-start`, `sequence-advance`, `sequence-clear`, `binding-execute` and `binding-reject`.
+
+Diagnostic events are not batched through `state`; they are emitted when the warning or error is reported.
+
+`WarningEvent` and `ErrorEvent` payloads:
+
+| Payload type   | Fields                       |
+| -------------- | ---------------------------- |
+| `WarningEvent` | `code`, `message`, `warning` |
+| `ErrorEvent`   | `code`, `message`, `error`   |
+
+Diagnostic behavior:
+
+- If no `warning` listener is registered, the keymap falls back to `console.warn(...)` for warnings.
+- If no `error` listener is registered, the keymap falls back to `console.error(...)` for errors.
+- Console fallback is per event type. Registering a `warning` listener suppresses warning console output but does not affect `error`, and vice versa.
+- Console fallback prefixes the message with `[code]`. If the underlying cause is an `Error`, it is passed as the second console argument.
+- Throwing `warning` or `error` listeners do not stop remaining diagnostic listeners from running, and they do not recursively emit another keymap error event.
+- `warning` commonly covers analyzer and validation warnings such as unknown fields, tokens or sequence patterns.
+- `error` covers more than registration failures: it also reports resolver failures, command-query failures, runtime matcher failures, and thrown `state`, `pendingSequence` or `dispatch` listeners.
+
+`keymap.intercept(...)`:
+
+| Form                         | Description                                                                                                                 |
+| ---------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| `intercept("key", fn)`       | Runs before binding dispatch. Context exposes `event`, `setData`, `getData` and `consume()`                                 |
+| `intercept("key:after", fn)` | Runs after binding dispatch. Context exposes `handled`, `reason`, `sequence`, `event`, `setData`, `getData` and `consume()` |
+| `intercept("raw", fn)`       | Runs on raw host input before key parsing. Context exposes `sequence` and `stop()`                                          |
+
+Intercept options:
+
+| Option     | Applies to | Description                               |
+| ---------- | ---------- | ----------------------------------------- |
+| `priority` | all        | Higher numbers run first                  |
+| `release`  | key forms  | Listen to release events instead of press |
+
+`key:after` listeners are delivered once per key event that reaches the keymap listener, including no-match, rejected-binding, pending-sequence, and pre-intercept-consumed outcomes. Delivery is not gated by `preventDefault()` or `stopPropagation()`; those methods only affect host propagation/default behavior. The after context is only constructed when a matching `key:after` listener is registered.
+
+## Extension points
+
+| API                                        | Use for                                                                       |
+| ------------------------------------------ | ----------------------------------------------------------------------------- |
+| `registerToken(token)`                     | Define named single-stroke aliases such as `leader`                           |
+| `registerSequencePattern(pattern)`         | Define named runtime sequence captures such as `count`                        |
+| `registerLayerFields(fields)`              | Add custom layer fields with `require(...)`, `attr(...)`, `activeWhen(...)`   |
+| `registerBindingFields(fields)`            | Add custom binding fields with `require(...)`, `attr(...)`, `activeWhen(...)` |
+| `registerCommandFields(fields)`            | Add custom command fields with `require(...)`, `attr(...)`, `activeWhen(...)` |
+| `prepend/appendBindingParser(parser)`      | Add new key string syntaxes                                                   |
+| `prepend/appendBindingExpander(expander)`  | Expand one key string into expansion objects, optionally preserving displays  |
+| `prepend/appendBindingTransformer(fn)`     | Rewrite parsed bindings or add derived bindings                               |
+| `prepend/appendCommandTransformer(fn)`     | Rewrite registered commands or add derived commands before command fields     |
+| `prepend/appendCommandResolver(resolver)`  | Resolve string commands dynamically                                           |
+| `prepend/appendLayerAnalyzer(analyzer)`    | Emit warnings or errors while layers compile                                  |
+| `prepend/appendEventMatchResolver(fn)`     | Add alternate event-to-stroke matching                                        |
+| `prepend/appendDisambiguationResolver(fn)` | Choose exact-vs-prefix behavior for ambiguous sequences                       |
+| `acquireResource(symbol, setup)`           | Share ref-counted setup/teardown across multiple addon registrations          |
+
+Every registration method above returns a disposer. The matching `clear*()` methods remove all registrations for that stage.
+
+## Disambiguation
+
+Ambiguity happens when the same sequence is both an exact command and a prefix of a longer binding, for example `g` and `gg`.
+
+Same-layer exact/prefix ambiguity is only allowed when at least one disambiguation resolver is registered. Without one, registering both `g` and `gg` in the same layer emits a compile error and keeps the valid earlier bindings.
+
+```ts
+keymap.appendDisambiguationResolver((ctx) => {
+  if (ctx.sequence.length === 1) {
+    return ctx.continueSequence()
+  }
+
+  return ctx.runExact()
+})
+```
+
+Resolver context exposes:
+
+| Member                | Description                                    |
+| --------------------- | ---------------------------------------------- |
+| `event`               | Current key event without mutation methods     |
+| `focused`             | Current focused target                         |
+| `sequence` / `stroke` | Current pending sequence and latest stroke     |
+| `exact`               | Exact bindings at the current sequence         |
+| `continuations`       | Reachable continuation keys                    |
+| `getData` / `setData` | Runtime data access                            |
+| `runExact()`          | Dispatch the exact binding now                 |
+| `continueSequence()`  | Keep the prefix pending                        |
+| `clear()`             | Clear the pending sequence and consume the key |
+| `defer(handler)`      | Start cancellable async disambiguation work    |
+
+Disambiguation resolvers must return synchronously. For async behavior, use `ctx.defer(...)`. If no resolver decides, the engine falls back to prefix handling and emits a warning.
+
+`defer(handler)` invokes `handler` with a `KeyDeferredDisambiguationContext`:
+
+| Member               | Description                                                                                               |
+| -------------------- | --------------------------------------------------------------------------------------------------------- |
+| `signal`             | `AbortSignal` aborted when a new key, focus change, or `clearPendingSequence()` cancels the deferred work |
+| `sequence`           | Pending sequence captured when `defer` was called                                                         |
+| `focused`            | Focused target captured when `defer` was called                                                           |
+| `sleep(ms)`          | Resolves to `true` if the timeout elapsed, `false` if `signal` aborted first                              |
+| `runExact()`         | Decision: dispatch the captured exact binding                                                             |
+| `continueSequence()` | Decision: keep the prefix pending                                                                         |
+| `clear()`            | Decision: clear the pending sequence                                                                      |
+
+The handler may return a decision, a `Promise<decision>`, or nothing (no-op). Returning nothing after the signal aborted is the canonical cancel path.
+
+## Constraints
+
+- Runtime/data re-entry is supported during dispatch. Command handlers, intercepts and pending-sequence listeners can read and write runtime data.
+- Structural re-entry is not supported during dispatch. Do not register or unregister layers, parsers, resolvers, tokens, or similar environment-shaping state while a dispatch is in flight.
+- After the host is destroyed, host-backed reads such as `getActiveKeys()` are unavailable. Metadata reads such as `getCommands()` and runtime data access remain usable.
diff --git a/.agents/skills/opentui/docs/keymap/custom-addons.mdx b/.agents/skills/opentui/docs/keymap/custom-addons.mdx
new file mode 100644
index 0000000..9832aca
--- /dev/null
+++ b/.agents/skills/opentui/docs/keymap/custom-addons.mdx
@@ -0,0 +1,507 @@
+---
+title: Custom Addons
+description: Public addon-authoring APIs, callback contexts and extension-point constraints
+order: 7
+navTitle: Custom Addons
+---
+
+# Custom keymap addons
+
+An addon is usually a function that accepts a `Keymap`, registers one or more behaviors, and returns a disposer.
+
+The important constraint is that custom addons should stay on the public surface. The shipped addons use the same public registration APIs.
+
+If you want the shipped addon inventory instead, see [Built-in Addons](/docs/keymap/addons).
+
+## Addon shape
+
+```ts
+import type { Keymap, KeymapEvent } from "@opentui/keymap"
+
+export function registerModeField<TTarget extends object, TEvent extends KeymapEvent>(
+  keymap: Keymap<TTarget, TEvent>,
+): () => void {
+  const offField = keymap.registerBindingFields({
+    mode(value, ctx) {
+      ctx.require("app.mode", value)
+      ctx.attr("mode", value)
+    },
+  })
+
+  const offIntercept = keymap.intercept("key", ({ event, setData }) => {
+    if (event.name === "escape") {
+      setData("app.mode", "normal")
+    }
+  })
+
+  return () => {
+    offIntercept()
+    offField()
+  }
+}
+```
+
+Guidelines:
+
+- Return one disposer that tears down everything the addon registered.
+- Clean up in reverse order when the registrations depend on one another.
+- Prefer composing the public registration methods over reaching into internal services.
+
+## Public registration APIs
+
+### Fields, tokens, and patterns
+
+| API                                | Use for                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------------- |
+| `registerToken(token)`             | Define named single-stroke aliases such as `leader`                           |
+| `registerSequencePattern(pattern)` | Define named runtime sequence captures such as `count`                        |
+| `registerLayerFields(fields)`      | Add custom layer fields with `require(...)`, `attr(...)`, `activeWhen(...)`   |
+| `registerBindingFields(fields)`    | Add custom binding fields with `require(...)`, `attr(...)`, `activeWhen(...)` |
+| `registerCommandFields(fields)`    | Add custom command fields with `require(...)`, `attr(...)`, `activeWhen(...)` |
+
+### Binding pipeline
+
+| API                                        | Use for                                                       |
+| ------------------------------------------ | ------------------------------------------------------------- |
+| `prepend/appendLayerBindingsTransformer()` | Rewrite a whole layer's binding array once before compilation |
+| `prepend/appendBindingExpander()`          | Expand one key string into one or more expansion objects      |
+| `prepend/appendBindingParser()`            | Parse string key syntax into normalized sequence parts        |
+| `prepend/appendBindingTransformer()`       | Rewrite parsed bindings or add derived bindings               |
+
+### Dispatch and command resolution
+
+| API                                      | Use for                                                 |
+| ---------------------------------------- | ------------------------------------------------------- |
+| `prepend/appendCommandResolver()`        | Resolve string commands dynamically                     |
+| `prepend/appendCommandTransformer()`     | Rewrite registered commands or add derived commands     |
+| `prepend/appendEventMatchResolver()`     | Add alternate event-to-stroke matching                  |
+| `prepend/appendDisambiguationResolver()` | Choose exact-vs-prefix behavior for ambiguous sequences |
+| `intercept("key", ...)`                  | Observe or consume key events before binding dispatch   |
+| `intercept("key:after", ...)`            | Observe dispatch outcomes after binding dispatch        |
+| `intercept("raw", ...)`                  | Observe raw host input before key parsing               |
+
+Event-match resolver order is global fallback priority: earlier matches are tried across all active layers before later matches. Use binding expanders or transformers for layer-local aliases.
+
+### Diagnostics and lifecycle
+
+| API                              | Use for                                                            |
+| -------------------------------- | ------------------------------------------------------------------ |
+| `prepend/appendLayerAnalyzer()`  | Emit warnings or errors while layers compile                       |
+| `acquireResource(symbol, setup)` | Share ref-counted setup and teardown across multiple registrations |
+| `keymap.on(...)`                 | Subscribe to state, dispatch and diagnostic events                 |
+
+Every registration API above returns a disposer.
+
+## Field compilers
+
+Field compilers turn user-supplied fields into activation rules and public metadata. Layer fields also feed binding pipeline callbacks.
+
+Mental model:
+
+| Term              | Meaning                      | Audience                         |
+| ----------------- | ---------------------------- | -------------------------------- |
+| Custom fields     | Raw config / addon DSL input | The keymap compiler and addons   |
+| Compiled metadata | Public metadata output       | Command palettes, hints and help |
+
+Fields can be behavior, metadata or both. Compiled metadata is only metadata.
+
+```ts
+keymap.registerBindingFields({
+  mode(value, ctx) {
+    ctx.require("app.mode", value)
+    ctx.attr("mode", value)
+  },
+})
+
+keymap.registerLayer({
+  bindings: [{ key: "x", mode: "normal", cmd() {} }],
+})
+```
+
+That `mode` field is both a condition and metadata. The binding is active only when `keymap.getData("app.mode")` is `"normal"`, and metadata queries can expose `{ mode: "normal" }`.
+
+| Context               | Methods                                        | Notes                                                        |
+| --------------------- | ---------------------------------------------- | ------------------------------------------------------------ |
+| `LayerFieldContext`   | `require(...)`, `attr(...)`, `activeWhen(...)` | Layer attrs can surface in graph snapshots                   |
+| `BindingFieldContext` | `require(...)`, `attr(...)`, `activeWhen(...)` | Binding attrs can surface on active bindings and active keys |
+| `CommandFieldContext` | `require(...)`, `attr(...)`, `activeWhen(...)` | Command attrs can surface on command queries and active keys |
+
+### `attr(...)`
+
+`attr(name, value)` publishes compiled metadata. It does not affect activation.
+
+The attr name does not have to match the field name. That is useful when an addon wants to validate, normalize, derive or standardize metadata before exposing it.
+
+```ts
+keymap.registerCommandFields({
+  title(value, ctx) {
+    ctx.attr("label", String(value).trim())
+  },
+})
+```
+
+Use same-name attrs when the field already is the public metadata shape:
+
+```ts
+keymap.registerCommandFields({
+  desc(value, ctx) {
+    ctx.attr("desc", String(value).trim())
+  },
+})
+```
+
+Use no attr when the field is behavior-only:
+
+```ts
+keymap.registerCommandFields({
+  enabled(value, ctx) {
+    ctx.activeWhen(() => value === true)
+  },
+})
+```
+
+Compiled metadata is exposed through projections such as `GraphLayer.attrs`, `ActiveBinding.attrs`, `ActiveBinding.commandAttrs`, `ActiveKey.bindingAttrs` and `ActiveKey.commandAttrs`. `getCommands()` returns the original command objects, not a separate metadata record.
+
+### `require(...)` vs `activeWhen(...)`
+
+Both gate activation. They differ in where the condition comes from.
+
+| Method                 | Use when                                      | Evaluation model                                                                     |
+| ---------------------- | --------------------------------------------- | ------------------------------------------------------------------------------------ |
+| `require(name, value)` | The condition is equality against keymap data | Checks `Object.is(keymap.getData(name), value)`                                      |
+| `activeWhen(callback)` | The condition is arbitrary code               | Calls the callback whenever the record is evaluated                                  |
+| `activeWhen(reactive)` | External state can notify when it changed     | Calls `reactive.get()` on reads and dispatch; `subscribe()` notifies state listeners |
+
+Use `require(...)` for keymap-owned state such as modes:
+
+```ts
+keymap.registerBindingFields({
+  mode(value, ctx) {
+    ctx.require("app.mode", value)
+  },
+})
+
+keymap.setData("app.mode", "insert")
+```
+
+Use `activeWhen(...)` for derived or external state:
+
+```ts
+keymap.registerBindingFields({
+  hasSelection(_value, ctx) {
+    ctx.activeWhen(() => editor.selection.length > 0)
+  },
+})
+```
+
+`require(...)` is a keyed equality check against runtime data. `ReactiveMatcher` is the subscription-aware matcher form:
+
+```ts
+interface ReactiveMatcher {
+  get(): boolean
+  subscribe(onChange: () => void): () => void
+}
+```
+
+### Surface rules
+
+| Surface | Field storage                                                                | Metadata output                                 |
+| ------- | ---------------------------------------------------------------------------- | ----------------------------------------------- |
+| Layer   | Extra layer fields feed layer compilers, parsers, expanders and transformers | `GraphLayer.attrs` in graph snapshots           |
+| Binding | Extra binding fields are consumed by binding-field compilers                 | `ActiveBinding.attrs`, `ActiveKey.bindingAttrs` |
+| Command | Extra command properties stay on the command object and feed compilers       | `commandAttrs` projections                      |
+
+Layer attrs are intentionally exposed on graph snapshots, not active keys, active bindings or command queries. Use them for debug and visualization metadata such as layer names.
+
+Unknown layer and binding fields are ignored and emit warnings. Unknown command fields stay on the command object, because command metadata is queryable even without a registered command-field compiler.
+
+## Binding pipeline callbacks
+
+String bindings go through an ordered pipeline.
+
+1. Expanders rewrite the input string.
+2. Parsers turn strings into `KeySequencePart[]`.
+3. Transformers rewrite parsed bindings or add more.
+
+Layer-binding transformers run earlier than that pipeline and only once, when the layer is registered. Use them when an addon needs to replace or filter the whole `Binding[]` set before compilation.
+
+Object-form keys such as `{ name: "return", ctrl: true }` skip string parsing and normalize directly.
+
+### `BindingExpanderContext`
+
+| Member     | Purpose                                                   |
+| ---------- | --------------------------------------------------------- |
+| `input`    | Current binding string                                    |
+| `displays` | Optional per-stroke display labels from earlier expanders |
+| `layer`    | Read-only view of the owning layer fields                 |
+
+Return expansion objects to replace one binding string with many, or `undefined` to leave the current candidate unchanged. `displays` must match the parsed sequence length for that expansion.
+
+```ts
+keymap.appendBindingExpander(({ input }) => {
+  if (input !== "save") return undefined
+  return [{ key: "ctrl+s", displays: ["save"] }]
+})
+```
+
+### `BindingParserContext`
+
+| Member                          | Purpose                                                                 |
+| ------------------------------- | ----------------------------------------------------------------------- |
+| `input` / `index`               | Current source string and parser position                               |
+| `layer`                         | Read-only layer fields                                                  |
+| `tokens`                        | Registered tokens available to this parser                              |
+| `patterns`                      | Registered sequence patterns available to this parser                   |
+| `normalizeTokenName(token)`     | Normalize token names consistently                                      |
+| `createMatch(id)`               | Create an opaque match id for custom event matching                     |
+| `parseObjectKey(key, options?)` | Normalize a stroke and optionally override display, match or token name |
+
+Return `{ parts, nextIndex }` to claim input, or `undefined` to let later parsers try.
+
+Parser syntax should stay inside the parser. Register tokens and sequence patterns with bare semantic names such as `"leader"` or `"count"`, then have the parser map whatever syntax it owns (`<leader>`, `{count}`, `[leader]`, `%count%`, etc.) to those names. Use `display` on parsed parts when you want graph/help UIs to preserve that syntax.
+
+### `BindingTransformerContext`
+
+| Member           | Purpose                                                            |
+| ---------------- | ------------------------------------------------------------------ |
+| `layer`          | Read-only layer fields                                             |
+| `parseKey(key)`  | Parse or normalize another key input using the current environment |
+| `add(binding)`   | Add a derived parsed binding                                       |
+| `skipOriginal()` | Drop the original parsed binding                                   |
+
+### `LayerBindingsTransformerContext`
+
+| Member                    | Purpose                                                           |
+| ------------------------- | ----------------------------------------------------------------- |
+| `layer`                   | Read-only layer definition                                        |
+| `validateBindings(array)` | Run the engine's structural binding validation on a binding array |
+
+Ordering rules:
+
+- `prepend*` registrations run before `append*` registrations.
+- `clearBindingExpanders()`, `clearBindingParsers()` and `clearBindingTransformers()` remove the entire stage for that keymap.
+
+Use the `clear*()` methods only when your addon owns that whole stage. They are global to the keymap, not scoped to your addon.
+
+## Command, event and disambiguation callbacks
+
+### `CommandTransformer`
+
+Command transformers run once for each command in a layer before command fields compile. They can mutate the command copy they receive, add derived commands or drop the original.
+
+| Member           | Purpose                      |
+| ---------------- | ---------------------------- |
+| `layer`          | Read-only layer definition   |
+| `add(command)`   | Add a derived command        |
+| `skipOriginal()` | Drop the transformed command |
+
+### `CommandResolver`
+
+```ts
+;(command, ctx) => Command | undefined
+```
+
+`CommandResolverContext` exposes:
+
+| Member                | Purpose                                                  |
+| --------------------- | -------------------------------------------------------- |
+| `input`               | Current invocation input                                 |
+| `payload`             | Current invocation payload                               |
+| `setInput(input)`     | Replace the input passed to the returned command         |
+| `setPayload(payload)` | Replace the payload passed to the returned command       |
+| `getCommand(name)`    | Read the registered command for the current mode, if any |
+
+Resolver commands use the same shape as registered commands: `name`, `run` and optional custom top-level fields.
+
+Return an explicit command result from `run()` when the command wants a specific failure reason:
+
+```ts
+return {
+  name: ":write",
+  run() {
+    return { ok: false, reason: "invalid-args" }
+  },
+}
+```
+
+Resolver results are resolved when command queries, bindings, `runCommand()` or `dispatchCommand()` need them.
+Programmatic `runCommand()` and `dispatchCommand()` resolve the supplied command string for each call.
+Put per-execution behavior in the returned `run(ctx)` handler.
+
+### `EventMatchResolver`
+
+```ts
+(event, ctx) => readonly KeyMatch[] | undefined
+```
+
+`EventMatchResolverContext` exposes `resolveKey(key)`, which lets a resolver map a host event to the same matching representation used by parsed bindings.
+
+### `KeyDisambiguationResolver`
+
+Use this when the same sequence is both an exact command and a prefix, such as `g` and `gg`.
+
+Register a disambiguation resolver before registering same-layer exact/prefix bindings. Without a resolver, the compiler rejects the ambiguous binding and keeps the valid earlier bindings.
+
+`KeyDisambiguationContext` exposes:
+
+| Member                    | Purpose                                     |
+| ------------------------- | ------------------------------------------- |
+| `event`                   | Current key event without mutation methods  |
+| `focused`                 | Current focused target                      |
+| `sequence` / `stroke`     | Pending sequence and latest stroke          |
+| `exact`                   | Exact matching bindings                     |
+| `continuations`           | Reachable next keys                         |
+| `getData()` / `setData()` | Runtime data access                         |
+| `runExact()`              | Dispatch the exact binding now              |
+| `continueSequence()`      | Keep the sequence pending                   |
+| `clear()`                 | Clear the pending sequence                  |
+| `defer(handler)`          | Start cancellable async disambiguation work |
+
+Disambiguation resolvers themselves must return synchronously. If you need async behavior, use `ctx.defer(...)`. The handler receives a `KeyDeferredDisambiguationContext`:
+
+| Member               | Purpose                                                                                                   |
+| -------------------- | --------------------------------------------------------------------------------------------------------- |
+| `signal`             | `AbortSignal` aborted when a new key, focus change, or `clearPendingSequence()` cancels the deferred work |
+| `sequence`           | Pending sequence captured when `defer` was called                                                         |
+| `focused`            | Focused target captured when `defer` was called                                                           |
+| `sleep(ms)`          | Resolves to `true` if the timeout elapsed, `false` if `signal` aborted first                              |
+| `runExact()`         | Decision: dispatch the captured exact binding                                                             |
+| `continueSequence()` | Decision: keep the prefix pending                                                                         |
+| `clear()`            | Decision: clear the pending sequence                                                                      |
+
+The handler may return a decision, a `Promise<decision>`, or nothing. Return nothing after `signal` aborts to drop the deferred work without dispatching.
+
+Command handlers are different: they may return a promise, but only a synchronous `false` rejects the current candidate and lets lower-precedence handlers continue.
+
+### `LayerAnalyzer`
+
+Analyzers run while a layer compiles and receive a projected view of the compiled bindings.
+
+`LayerAnalysisContext` exposes:
+
+| Member                                       | Purpose                                            |
+| -------------------------------------------- | -------------------------------------------------- |
+| `target` / `order`                           | Source layer identity                              |
+| `sourceBindings`                             | Original bindings after layer-binding transformers |
+| `bindings`                                   | Compiled binding analysis records                  |
+| `hasTokenBindings`                           | Whether any binding used tokens                    |
+| `checkCommandResolution(command)`            | Probe whether a string command resolves            |
+| `warn(...)` / `warnOnce(...)` / `error(...)` | Emit diagnostics                                   |
+
+`clearLayerAnalyzers()` removes all registered analyzers for the keymap.
+
+## Hooks, intercepts and runtime helpers
+
+### `keymap.on(...)`
+
+| Event             | Payload             | Notes                                           |
+| ----------------- | ------------------- | ----------------------------------------------- |
+| `state`           | `void`              | Batched "derived state may have changed" signal |
+| `pendingSequence` | `KeySequencePart[]` | Synchronous pending-sequence updates            |
+| `dispatch`        | `DispatchEvent`     | Sequence and binding execution trace events     |
+| `warning`         | `WarningEvent`      | Validation or analyzer warning                  |
+| `error`           | `ErrorEvent`        | Registration, query, resolver or listener error |
+
+### `keymap.intercept(...)`
+
+| Form                                   | Context                                                                     |
+| -------------------------------------- | --------------------------------------------------------------------------- |
+| `intercept("key", fn, options?)`       | `event`, `setData`, `getData`, `consume()`                                  |
+| `intercept("key:after", fn, options?)` | `handled`, `reason`, `sequence`, `event`, `setData`, `getData`, `consume()` |
+| `intercept("raw", fn, options?)`       | `sequence`, `stop()`                                                        |
+
+Options:
+
+| Option     | Applies to | Notes                                     |
+| ---------- | ---------- | ----------------------------------------- |
+| `priority` | all        | Higher numbers run first                  |
+| `release`  | key forms  | Listen to release events instead of press |
+
+`key:after` is a synchronous post-dispatch hook for optionally calling `preventDefault()` / `stopPropagation()` after observing whether the keymap handled, rejected, missed, or held a sequence. It still fires if the event is already default-prevented or propagation-stopped; those flags affect host delivery, not after-hook delivery.
+
+### Useful runtime helpers inside addons
+
+| API                                                                        | Use for                                                         |
+| -------------------------------------------------------------------------- | --------------------------------------------------------------- |
+| `getData()` / `setData()`                                                  | Shared mutable runtime state                                    |
+| `getPendingSequence()` / `clearPendingSequence()` / `popPendingSequence()` | Sequence-aware addons                                           |
+| `createKeyMatcher(key)`                                                    | Match a stroke using the current parser and token configuration |
+| `getActiveKeys()` / `getGraphSnapshot(keymap)`                             | Build hint, graph or debug UIs                                  |
+| `getCommands()` / `getCommandEntries()` / `getCommandBindings()`           | Inspect command metadata and binding projections                |
+
+`getGraphSnapshot()` is imported from `@opentui/keymap/extras/graph`; the other helpers are `Keymap` methods.
+
+## Shared resources with `acquireResource()`
+
+`acquireResource(symbol, setup)` is the public way to share setup and teardown across multiple addon registrations on the same keymap.
+
+Behavior:
+
+- the first acquisition for a symbol runs `setup()`
+- later acquisitions for the same symbol reuse the existing resource
+- the resource disposer runs only when the last holder releases it
+- active resources are disposed when the host is destroyed
+- a failed `setup()` is not retained as a partially registered resource
+
+This is how the OpenTUI textarea helpers safely share command and suspension infrastructure.
+
+## Testing Addons
+
+`@opentui/keymap/testing` provides a small host-agnostic test harness for addon authors. It does not depend on OpenTUI renderers or `@opentui/core/testing`.
+
+```ts
+import { createTestKeymap } from "@opentui/keymap/testing"
+import { registerMyAddon } from "./my-addon"
+
+const { keymap, host, diagnostics, cleanup } = createTestKeymap({ defaultKeys: true })
+
+registerMyAddon(keymap)
+keymap.registerLayer({
+  commands: [{ name: "save", run() {} }],
+  bindings: [{ key: "x", cmd: "save" }],
+})
+
+host.press("x")
+diagnostics.takeErrors()
+cleanup()
+```
+
+Testing exports include:
+
+| API                                                       | Use for                                                                      |
+| --------------------------------------------------------- | ---------------------------------------------------------------------------- |
+| `createTestKeymap(options?)`                              | Create a `Keymap`, fake host, root target, and diagnostic capture            |
+| `createTestKeymapHost(options?)`                          | Create only the fake `KeymapHost` when tests need manual keymap construction |
+| `createTestHostMetadata(options?)`                        | Build host metadata for platform/modifier-sensitive addons                   |
+| `captureKeymapDiagnostics(keymap)`                        | Capture warnings/errors without depending on a specific test framework       |
+| `TestKeymapHost` / `TestKeymapTarget` / `TestKeymapEvent` | Reusable fake host primitives                                                |
+
+The fake host supports press/release events, focus changes, parent traversal, target destruction, host destruction, and raw input. Use adapter-specific test utilities only when an addon is actually testing an adapter such as OpenTUI or HTML.
+
+## Constraints and quirks
+
+### Reserved field names
+
+| Registration surface | Reserved names                                             |
+| -------------------- | ---------------------------------------------------------- |
+| Layer fields         | `target`, `targetMode`, `priority`, `bindings`, `commands` |
+| Binding fields       | `key`, `cmd`, `event`, `preventDefault`, `fallthrough`     |
+| Command fields       | `name`, `run`                                              |
+
+### Warnings vs errors
+
+- Unknown custom layer and binding fields are ignored and emit warnings.
+- Unknown custom command fields stay on the command object.
+- Unknown tokens or sequence patterns inside binding strings are ignored and emit warnings.
+- Registering the missing token or pattern later recompiles affected layers.
+
+### Re-entry
+
+- Runtime/data-style re-entry is supported during dispatch. Commands, intercepts and pending-sequence listeners may read and write runtime data.
+- Structural re-entry is not supported during dispatch. Do not register or unregister layers, parsers, resolvers, tokens or similar environment-shaping state while a dispatch is in flight.
+
+### Host-dependent behavior
+
+- `intercept("raw", ...)` only works when the host implements `onRawInput()`.
+- Raw hosts must stop raw input propagation when an `onRawInput()` listener returns `true`.
+- After the host is destroyed, host-backed reads such as `getActiveKeys()` are unavailable, but metadata reads such as `getCommands()` and runtime data access remain usable.
diff --git a/.agents/skills/opentui/docs/keymap/hosts.mdx b/.agents/skills/opentui/docs/keymap/hosts.mdx
new file mode 100644
index 0000000..227cac2
--- /dev/null
+++ b/.agents/skills/opentui/docs/keymap/hosts.mdx
@@ -0,0 +1,256 @@
+---
+title: Hosts
+description: Built-in OpenTUI and HTML adapters plus the KeymapHost contract
+order: 2
+navTitle: Hosts
+---
+
+# Keymap hosts
+
+OpenTUI Keymap is host-agnostic. A host adapts a runtime's focus model, hierarchy, key events and lifecycle into `KeymapHost<TTarget, TEvent>` so the shared engine can work against it.
+
+The package ships two built-in hosts:
+
+- `@opentui/keymap/opentui` for terminal apps built on `CliRenderer` and `Renderable`
+- `@opentui/keymap/html` for browser UIs rooted in an `HTMLElement`
+
+If you have not read the shared model yet, start with [Keymap overview](/docs/keymap/overview).
+
+## What a host does
+
+The keymap core does not know about DOM nodes, terminal renderables or any other UI tree. It only knows about host targets and host events.
+
+- `target` on a local layer is a host target object.
+- `focus` and `focus-within` activation come from the host's focused target and parent traversal.
+- key press and key release events come from the host event stream.
+- local layers are cleaned up when the host reports that their target was destroyed or removed.
+- host metadata describes platform shortcut conventions and modifier support for addons.
+- `runCommand()` and `dispatchCommand()` need the host to create a synthetic event for programmatic execution.
+- raw input interception only exists when the host implements the optional raw-input hook.
+
+## `KeymapHost`
+
+| Member                              | Required | Purpose                                                                                                    |
+| ----------------------------------- | -------- | ---------------------------------------------------------------------------------------------------------- |
+| `metadata`                          | yes      | Platform, primary shortcut modifier and modifier capability metadata                                       |
+| `rootTarget`                        | yes      | Root target for the host hierarchy                                                                         |
+| `isDestroyed`                       | yes      | Host lifetime flag                                                                                         |
+| `getFocusedTarget()`                | yes      | Returns the currently focused target or `null`                                                             |
+| `getParentTarget(target)`           | yes      | Parent traversal used for `focus-within` matching                                                          |
+| `isTargetDestroyed(target)`         | yes      | Target liveness check                                                                                      |
+| `onKeyPress(listener)`              | yes      | Subscribes to press events                                                                                 |
+| `onKeyRelease(listener)`            | yes      | Subscribes to release events                                                                               |
+| `onFocusChange(listener)`           | yes      | Subscribes to focus changes                                                                                |
+| `onTargetDestroy(target, listener)` | yes      | Notifies when a local layer target is destroyed or removed                                                 |
+| `createCommandEvent()`              | yes      | Creates the synthetic event used by `runCommand()` and `dispatchCommand()`                                 |
+| `onDestroy(listener)`               | no       | Optional host-destroy notification                                                                         |
+| `onRawInput(listener)`              | no       | Optional raw input hook used before key parsing. The listener returns `true` when it consumed the sequence |
+
+If you are building your own runtime adapter, implement this contract and pass it to `new Keymap(host)`.
+
+Host metadata is available through `keymap.getHostMetadata()`. `primaryModifier` is the modifier that addon syntax such as `mod+s` should resolve to. Capability values are `supported`, `unsupported` or `unknown`; terminal hosts use `unknown` when the event type can represent a modifier but actual terminal delivery depends on protocol support.
+
+| Metadata field    | Meaning                                                          |
+| ----------------- | ---------------------------------------------------------------- |
+| `platform`        | `macos`, `windows`, `linux` or `unknown`                         |
+| `primaryModifier` | `super` on macOS, `ctrl` on Windows/Linux, or `unknown`          |
+| `modifiers`       | Host capability for `ctrl`, `shift`, `meta`, `super` and `hyper` |
+
+Host key events must satisfy `KeymapEvent`:
+
+| Member                    | Purpose                                                                           |
+| ------------------------- | --------------------------------------------------------------------------------- |
+| `name`                    | Normalized key name                                                               |
+| `ctrl` / `shift` / `meta` | Modifier state                                                                    |
+| `super` / `hyper`         | Optional extra modifier state                                                     |
+| `preventDefault()`        | Prevent the matched event from reaching the host target                           |
+| `stopPropagation()`       | Stop later listeners from seeing the event and set `propagationStopped` to `true` |
+| `propagationStopped`      | `true` after `stopPropagation()` was called                                       |
+
+If your host implements `onRawInput()`, it must call each listener before key parsing and stop when a listener returns `true`.
+
+## Built-in host helpers
+
+Both built-in host packages export adapter-specific helpers. Import the shared `Keymap`, stringifiers and core types from `@opentui/keymap`.
+
+| Package                   | Host adapter                        | Bare keymap helper              | Default helper                         |
+| ------------------------- | ----------------------------------- | ------------------------------- | -------------------------------------- |
+| `@opentui/keymap/opentui` | `createOpenTuiKeymapHost(renderer)` | `createOpenTuiKeymap(renderer)` | `createDefaultOpenTuiKeymap(renderer)` |
+| `@opentui/keymap/html`    | `createHtmlKeymapHost(root)`        | `createHtmlKeymap(root)`        | `createDefaultHtmlKeymap(root)`        |
+
+- The host adapter returns a `KeymapHost` implementation.
+- The bare helper creates a `new Keymap(host)` with only the host installed; parser and addon stages remain opt-in.
+- The default helper starts from the bare helper and installs the small default addon set for that host.
+
+## OpenTUI host
+
+`@opentui/keymap/opentui` is the host package for terminal apps built on `@opentui/core`.
+
+### What it adds
+
+- `createOpenTuiKeymapHost(renderer)` - adapts `CliRenderer` and `Renderable` to `KeymapHost`
+- `createOpenTuiKeymap(renderer)` - creates a bare `Keymap<Renderable, KeyEvent>`
+- `createDefaultOpenTuiKeymap(renderer)` - creates an OpenTUI keymap with default keys, enabled fields and metadata fields installed
+
+### Basic usage
+
+```ts
+import { createCliRenderer } from "@opentui/core"
+import { createDefaultOpenTuiKeymap } from "@opentui/keymap/opentui"
+
+const renderer = await createCliRenderer()
+const keymap = createDefaultOpenTuiKeymap(renderer)
+
+keymap.registerLayer({
+  commands: [
+    {
+      name: "quit",
+      run() {
+        renderer.destroy()
+      },
+    },
+  ],
+  bindings: [{ key: "q", cmd: "quit" }],
+})
+```
+
+If you want to control the installed addons yourself, start from `createOpenTuiKeymap(renderer)` and register addons manually.
+
+### Host behavior
+
+| Behavior                | OpenTUI adapter                                                                                                                                       |
+| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Root target             | `renderer.root`                                                                                                                                       |
+| Focused target          | `renderer.currentFocusedRenderable` when still focused and not destroyed                                                                              |
+| Parent traversal        | `Renderable.parent`                                                                                                                                   |
+| Target destroy tracking | `RenderableEvents.DESTROYED`                                                                                                                          |
+| Host destroy tracking   | `CliRenderEvents.DESTROY`                                                                                                                             |
+| Press/release events    | `renderer.keyInput` `keypress` and `keyrelease`                                                                                                       |
+| Raw input interception  | `renderer.prependInputHandler(...)`                                                                                                                   |
+| Synthetic command event | New `KeyEvent` with `name: "command"`                                                                                                                 |
+| Host metadata           | Runtime platform; `ctrl`, `shift` and `meta` supported; `super`/`hyper` supported when terminal capabilities report Kitty keyboard, otherwise unknown |
+
+`createOpenTuiKeymap(renderer)` throws if the renderer is already destroyed.
+
+### Default helper
+
+`createDefaultOpenTuiKeymap(renderer)` installs:
+
+- `registerDefaultKeys()`
+- `registerEnabledFields()`
+- `registerMetadataFields()`
+
+It does not install leader tokens, ex commands, disambiguation addons, warning analyzers, base-layout fallback or textarea helpers. Call `registerBaseLayoutFallback()` from `@opentui/keymap/addons/opentui` if you want bindings to ignore active keyboard-layout changes.
+
+### Event notes
+
+- Press and release events come directly from the renderer's key input stream.
+- Programmatic `runCommand()` and `dispatchCommand()` calls receive the synthetic `KeyEvent` created by `createCommandEvent()`.
+- Kitty-specific fields on `KeyEvent`, such as `baseCode`, stay available to addons like `registerBaseLayoutFallback()`.
+
+### OpenTUI-specific addons
+
+`@opentui/keymap/addons/opentui` adds helpers on top of the shared addon set:
+
+- `registerBaseLayoutFallback()` - match against Kitty base-layout codepoints
+- `createTextareaBindings()` - generate textarea bindings from the shared edit-buffer command set
+- `registerEditBufferCommands()` - register the edit-buffer command layer against `renderer.currentFocusedEditor`
+- `registerTextareaMappingSuspension()` - suspend a focused `TextareaRenderable`'s built-in mapped shortcuts
+- `registerManagedTextareaLayer()` - high-level textarea integration combining the helpers above
+
+Example: `packages/examples/src/keymap-demo.ts`
+
+See [Built-in Addons](/docs/keymap/addons) for the rest of the shipped addon surface and [Custom Addons](/docs/keymap/custom-addons) for addon authoring.
+
+## HTML host
+
+`@opentui/keymap/html` is the host package for browser UIs rooted in an `HTMLElement` subtree.
+
+Live demo: [HTML keymap demo](/demos/keymap-html/)
+
+### What it adds
+
+- `HtmlKeymapEvent` - shared keymap event plus optional `originalEvent: KeyboardEvent`
+- `normalizeHtmlKeyName(key)` - normalizes browser `event.key` values to keymap names
+- `createHtmlKeymapEvent(event?)` - wraps a `KeyboardEvent` in `HtmlKeymapEvent`
+- `createHtmlKeymapHost(root)` - adapts an `HTMLElement` subtree to `KeymapHost`
+- `htmlEventMatchResolver` - HTML-specific event matcher for browser key events
+- `createHtmlKeymap(root)` - creates a bare `Keymap<HTMLElement, HtmlKeymapEvent>`
+- `createDefaultHtmlKeymap(root)` - creates an HTML keymap with default keys, enabled fields, metadata fields and HTML event matching installed
+
+### Basic usage
+
+```ts
+import { createDefaultHtmlKeymap } from "@opentui/keymap/html"
+
+const root = document.getElementById("app")!
+const keymap = createDefaultHtmlKeymap(root)
+
+keymap.registerLayer({
+  commands: [
+    {
+      name: "toggle-help",
+      run() {
+        document.body.classList.toggle("help-open")
+      },
+    },
+  ],
+  bindings: [{ key: "?", cmd: "toggle-help" }],
+})
+```
+
+If you want to control parser or event-matching stages yourself, start from `createHtmlKeymap(root)` and install the pieces manually.
+
+### Key normalization
+
+| Browser input | Keymap result | Notes                                                                 |
+| ------------- | ------------- | --------------------------------------------------------------------- |
+| `ArrowLeft`   | `left`        | Navigation keys are normalized to the shared canonical names          |
+| `Enter`       | `return`      | Canonical name is `return`; display stringifiers render it as `enter` |
+| `A`           | `a`           | Printable names are lowercased                                        |
+| `F12`         | `f12`         | Function keys are normalized to lowercase                             |
+| `altKey`      | `meta`        | Keymap uses `meta` for Alt/Option                                     |
+| `metaKey`     | `super`       | Keymap uses `super` for the platform Meta key                         |
+
+The HTML matcher also adds an unshifted match candidate for shifted printable punctuation, so bindings such as `":"` and `"?"` work as literal keys instead of forcing `shift+semicolon`-style spellings.
+
+### Host behavior
+
+| Behavior                | HTML adapter                                                                         |
+| ----------------------- | ------------------------------------------------------------------------------------ |
+| Root target             | The `HTMLElement` passed to `createHtmlKeymapHost()` / `createHtmlKeymap()`          |
+| Focused target          | `document.activeElement` when it is the root or a descendant                         |
+| Parent traversal        | `HTMLElement.parentElement`                                                          |
+| Target destroy tracking | `MutationObserver` over the root subtree when available                              |
+| Host destroy tracking   | None; root reachability is the lifetime model                                        |
+| Press/release events    | `keydown` and `keyup` listeners on the root in capture phase                         |
+| Raw input interception  | Not provided by the HTML host                                                        |
+| Synthetic command event | `createHtmlKeymapEvent()` with no DOM event                                          |
+| Host metadata           | Browser platform; `ctrl`, `shift`, `meta` and `super` supported; `hyper` unsupported |
+
+When a target element disconnects from the rooted subtree, local layers registered against it are removed.
+
+### Default helper
+
+`createDefaultHtmlKeymap(root)` installs:
+
+- `registerDefaultKeys()`
+- `registerEnabledFields()`
+- `registerMetadataFields()`
+- `htmlEventMatchResolver` via `prependEventMatchResolver(...)` so HTML-specific matching runs before the canonical matcher
+
+Call `prependEventMatchResolver(...)` for any custom resolver that must run before the HTML matcher.
+
+## Custom hosts
+
+If neither built-in host fits your runtime, implement `KeymapHost` yourself and construct the engine directly:
+
+```ts
+import { Keymap, type KeymapHost } from "@opentui/keymap"
+
+const keymap = new Keymap(host as KeymapHost<object>)
+```
+
+Custom hosts must provide conservative metadata. Use `unknown` when the host cannot prove a platform or modifier capability.
+
+Use [Core](/docs/keymap/core) for the bare engine APIs and extension points.
diff --git a/.agents/skills/opentui/docs/keymap/overview.mdx b/.agents/skills/opentui/docs/keymap/overview.mdx
new file mode 100644
index 0000000..8d8566b
--- /dev/null
+++ b/.agents/skills/opentui/docs/keymap/overview.mdx
@@ -0,0 +1,322 @@
+---
+title: Overview
+description: Shared binding, command and sequence engine for OpenTUI hosts
+order: 1
+navTitle: Overview
+skill:
+  entry: true
+  intents: [keymap, keybindings, shortcuts, commands, leader, ex-commands]
+---
+
+# Keymap
+
+OpenTUI Keymap is a host-agnostic binding engine for terminals and the browser. It gives you layered shortcuts, discoverable commands, sequence handling and framework-ready state so one key system can drive the whole app.
+
+## Installation
+
+```bash
+bun install @opentui/keymap
+```
+
+Live demo: [HTML keymap demo](/demos/keymap-html/)
+
+A binding can target a named command, an inline handler, or a specific key event:
+
+```ts
+;[
+  { key: "x", cmd: "save-file" },
+  { key: "ctrl+x", event: "release", cmd: "cut" },
+  { key: "dd", cmd: "delete-line" },
+  { key: "<leader>s", cmd: ":write session.log" },
+  { key: "?", cmd: "toggle-help" },
+  {
+    key: "ctrl+k",
+    cmd({ keymap }) {
+      keymap.setData("palette.open", true)
+    },
+  },
+  { key: "escape", event: "release", cmd: "close-help" },
+  { key: { name: "return", ctrl: true }, cmd: "submit" },
+]
+```
+
+![Keymap Engine Concept Overview](/keymap-engine-overview.svg)
+
+## Register
+
+Shape the keymap by registering layers, tokens and addons. Each layer declares bindings that map keys or key sequences to commands, optionally scoped to a host target with a priority. Addons extend the engine with parsers, field compilers, command resolvers and more.
+
+- Use `registerLayer()` to add bindings and commands.
+- Use `registerToken()` to define named key aliases like `leader`, referenced by the default parser as `<leader>`.
+- Use `registerSequencePattern()` to define runtime sequence captures like `count`, referenced by the default parser as `{count}`.
+- Use addons to install parsers, field compilers, disambiguation and other behaviour.
+- Every registration call returns a disposer for cleanup.
+- See [Hosts](/docs/keymap/hosts) for how targets, hierarchy and focus enter the engine.
+
+## Dispatch
+
+When a key event arrives from the host, the engine walks the active layers to find matching bindings, resolves ambiguity between exact matches and sequence prefixes, and runs the winning command. Intercepts can observe or consume input before binding resolution.
+
+- Bindings are matched against active layers based on focus, priority and conditions.
+- Multi-stroke sequences build up a pending sequence until resolved.
+- Commands run in your application space. A synchronous `false` lets lower-precedence handlers continue; async commands are handled immediately and report async errors through diagnostics.
+- Use `intercept("key", ...)` or `intercept("raw", ...)` to hook into the input pipeline.
+- See [Hosts](/docs/keymap/hosts) for how built-in hosts deliver press, release, focus and optional raw input events.
+
+## Query
+
+Ask the keymap what is currently available. Query results reflect the live state -- they change when focus, pending sequence, runtime data or conditions change.
+
+- `getActiveKeys()` returns the keys that can fire from the current focus and pending state.
+- `getCommands()`, `getCommandEntries()` and `getCommandBindings()` return command metadata and binding projections.
+- `getPendingSequence()` returns the current multi-stroke prefix.
+- `runCommand()` and `dispatchCommand()` execute commands programmatically.
+- Subscribe to `on("state")` for batched change notifications.
+- See [Hosts](/docs/keymap/hosts) for how host focus and target lifecycle affect what is active.
+
+## Bindings
+
+Bindings are data, not hard-coded event listeners. Each layer contributes binding records that the engine compiles into sequence trees and then projects through focus, priority, runtime conditions and pending-sequence state.
+
+### Binding shape
+
+A binding always has a `key`, and it can also specify `cmd`, `event`, `preventDefault`, `fallthrough` and any custom fields installed by addons or app code.
+
+- `key` can be a string like `"ctrl+x"`, `"dd"` or `"<leader>s"`, or an object stroke like `{ name: "return", ctrl: true }`.
+- `cmd` can be a named command string or an inline handler.
+- `event` defaults to `"press"`; use `"release"` for release bindings.
+- `preventDefault` defaults to `true` and calls `event.preventDefault()` plus `event.stopPropagation()` so the matched key does not reach the host target.
+- `fallthrough` defaults to `false`; setting `true` lets later matching bindings in the same dispatch chain still run after this command. It is independent of `preventDefault`, which controls whether the event escapes the keymap.
+
+Release bindings are supported, but only for a single stroke. Multi-stroke release bindings such as `"dd"` with `event: "release"` are rejected. Release bindings dispatch on key release, but they do not appear in `getActiveKeys()` because active-key discovery is based on press/pending-sequence state.
+
+### Parser-driven strings
+
+String keys are parser-driven. The engine does not hard-code one binding syntax into the core; it runs registered binding expanders, parsers and transformers to turn binding input into compiled sequences.
+
+- Expanders can rewrite one key string into multiple key strings.
+- Parsers turn a string into one or more normalized strokes.
+- Transformers can rewrite or add parsed bindings before the layer is compiled.
+
+The shared default parser accepts single-stroke named keys, modifier chords, literal punctuation, `" "` for space, `"+"` as a literal plus key, `<token>` aliases, `{pattern}` runtime captures, and concatenated multi-stroke sequences such as `"dd"`, `"<leader>s"`, or `"{count}j"`.
+
+Object-form keys are the escape hatch when you do not want string parsing. `{ name: "return", ctrl: true }` skips the string parser and normalizes directly to a single stroke.
+
+This parser-driven model is why the same engine can support built-in strings like `"ctrl+x"`, tokenized strings like `"<leader>s"`, pattern strings like `"{count}j"`, and addon-defined syntaxes such as bracket tokens or Emacs-style expansions.
+
+### Tokens
+
+Tokens are named single-stroke aliases used inside binding strings. Registration names are semantic and delimiter-free; the default parser maps `<leader>` syntax to the registered token named `"leader"`.
+
+```ts
+keymap.registerToken({ name: "leader", key: { name: "space" } })
+
+keymap.registerLayer({
+  bindings: [{ key: "<leader>s", cmd: "save-file" }],
+})
+```
+
+Tokens are compile-time input syntax, not a separate dispatch mode. They resolve to exactly one stroke, participate in sequence matching like any other stroke, and can be queried with their preserved display form.
+
+### Sequence patterns
+
+Sequence patterns are runtime captures used inside binding strings. Registration names are also semantic and delimiter-free; the default parser maps `{count}` syntax to the registered pattern named `"count"`.
+
+```ts
+import type { Command, KeymapEvent } from "@opentui/keymap"
+
+interface CountPayload {
+  count?: number
+}
+
+keymap.registerSequencePattern({
+  name: "count",
+  match(event) {
+    return /^\d$/.test(event.name) ? { value: event.name, display: event.name } : undefined
+  },
+  finalize(values) {
+    return Number(values.join(""))
+  },
+})
+
+const moveDownCommand: Command<object, KeymapEvent, CountPayload | undefined> = {
+  name: "move-down",
+  run({ payload }) {
+    moveDown(payload?.count ?? 1)
+  },
+}
+
+keymap.registerLayer({
+  commands: [moveDownCommand],
+  bindings: [
+    { key: "j", cmd: "move-down" },
+    { key: "{count}j", cmd: "move-down" },
+  ],
+})
+```
+
+By default, the command payload key is the pattern name, so `name: "count"` produces `payload.count`. Use `payloadKey` only when the command payload field should differ from the pattern name.
+
+### Custom binding fields
+
+Bindings can carry custom fields, but those fields only mean something after you register a binding-field compiler with `registerBindingFields()`. A binding field compiler can:
+
+- declare runtime requirements with `require(...)`
+- add runtime matchers with `activeWhen(...)`
+- expose metadata with `attr(...)`
+
+```ts
+keymap.registerBindingFields({
+  mode(value, ctx) {
+    ctx.require("vim.mode", value)
+    ctx.attr("mode", value)
+  },
+})
+
+keymap.registerToken({ name: "leader", key: { name: "space" } })
+
+keymap.registerLayer({
+  commands: [{ name: "write-file", run() {} }],
+  bindings: [{ key: "<leader>w", mode: "normal", cmd: "write-file" }],
+})
+```
+
+In that example, the binding is only active while `getData("vim.mode")` is `"normal"`, and the compiled binding metadata can expose `{ mode: "normal" }` through query APIs when metadata is requested.
+
+Unknown custom binding fields are not fatal. If no binding-field compiler is registered for a field, the keymap ignores that field and emits a warning.
+
+Layer fields follow the same compiler model. Register them with `registerLayerFields()` when you want layer-scoped activation, binding-pipeline inputs, or visualization metadata for graph snapshots:
+
+```ts
+keymap.registerLayerFields({
+  name(value, ctx) {
+    ctx.attr("name", String(value).trim())
+  },
+})
+
+keymap.registerLayer({
+  name: "Global",
+  bindings: [{ key: "?", cmd: "toggle-help" }],
+})
+```
+
+All host helpers use the same registration, dispatch and query model. They only differ in how they provide targets, focus and input events.
+
+## Fields and metadata
+
+Custom fields are raw config inputs. Compiled metadata is what field compilers expose to query UIs.
+
+| Name              | Meaning                                     | Example use                                     |
+| ----------------- | ------------------------------------------- | ----------------------------------------------- |
+| Custom fields     | What the layer, binding or command declared | `mode`, `enabled`, `desc`, `title`, `namespace` |
+| Compiled metadata | What field compilers expose to query UIs    | `desc`, `group`, `title`, `category`, `label`   |
+
+Fields can affect behavior. Metadata does not. A field compiler can make a record conditional with `require(...)` or `activeWhen(...)`, and it can separately publish metadata with `attr(...)`.
+
+```ts
+keymap.registerBindingFields({
+  mode(value, ctx) {
+    ctx.require("vim.mode", value)
+    ctx.attr("mode", value)
+  },
+})
+```
+
+That field does two things: it gates the binding on `keymap.getData("vim.mode")`, and it exposes `{ mode: value }` to active-key metadata when requested. Layer fields can also publish attrs, but those appear on `GraphLayer.attrs` for graph/debug projections rather than on active keys.
+
+Metadata can use a different name from the field when an addon wants to validate, normalize or present a stable public metadata shape:
+
+```ts
+keymap.registerCommandFields({
+  title(value, ctx) {
+    ctx.attr("label", String(value).trim())
+  },
+})
+```
+
+Use top-level custom fields for config DSL. Use `ctx.attr(...)` in field compilers for display/query metadata.
+
+## Commands
+
+Named commands are the stable app actions in the system. A layer can register a command with a `name`, a `run()` handler and optional top-level fields like `title`, `desc` or `namespace`, and bindings can point at that command by name. Inline binding handlers work too, but named commands are what power command palettes, search and programmatic execution.
+
+Command queries return the command objects you registered. Query search/filter can also use compiled command metadata produced by command-field addons. `runCommand()` executes the registered command chain directly, while `dispatchCommand()` goes through the active dispatch model and can return `inactive` or `disabled` when that command exists but is not currently dispatchable.
+
+## Runtime data
+
+Runtime data is the keymap's mutable key-value store. `setData()` and `getData()` let commands, intercepts and matchers share live state such as an editor mode, leader state or search context.
+
+That data also drives activation. Layer, binding and command fields can depend on runtime values through `require(...)` and `activeWhen(...)`, so changing a value immediately recomputes what is reachable. If the current pending sequence no longer matches after a data change, the engine clears it.
+
+`require(name, value)` is a keyed equality check against `keymap` runtime data. Use it for state the keymap owns, such as `vim.mode === "normal"`.
+
+`activeWhen(matcher)` is an arbitrary runtime predicate or `ReactiveMatcher`. Use it for derived or external state, such as whether an editor has a selection.
+
+### Application modes
+
+Runtime data is useful for application-specific modes that only exist to control keymap activation. Put that state on the keymap, expose it through a custom field, and let layers declare when they are active.
+
+```ts
+keymap.registerLayerFields({
+  appMode(value, ctx) {
+    ctx.require("app.mode", value)
+  },
+})
+
+keymap.setData("app.mode", "base")
+
+keymap.registerLayer({
+  appMode: "base",
+  bindings: [{ key: "ctrl+p", cmd: "palette.open" }],
+})
+
+keymap.registerLayer({
+  appMode: "palette",
+  bindings: [{ key: "escape", cmd: "palette.close" }],
+})
+```
+
+Changing `app.mode` recomputes active layers immediately. This keeps keymap-only state out of framework context or component props, while still letting normal layer ordering handle conflicts inside the active mode. If several independent overlays can be open at once, model that explicitly with a stack, depth counter or distinct mode values before writing the runtime data back.
+
+## Pending sequences and active keys
+
+A pending sequence is the prefix the user has already typed, such as `g` while waiting to see whether the next key completes `gg` or `gd`. `getPendingSequence()` exposes that prefix, and `clearPendingSequence()` / `popPendingSequence()` let addons or app code manage it explicitly.
+
+`getActiveKeys()` is the companion query. It does not list every registered binding; it projects the next reachable strokes from the current focus and pending state. That makes it the right API for key hints, which-key style UIs and other live discovery surfaces.
+
+## Entry points
+
+| Package                          | Description                                                                |
+| -------------------------------- | -------------------------------------------------------------------------- |
+| `@opentui/keymap`                | Main engine entry: `Keymap`, key stringifiers and shared types             |
+| `@opentui/keymap/addons`         | Universal addons for parser stages, metadata, diagnostics and sequences    |
+| `@opentui/keymap/addons/opentui` | Universal addons plus OpenTUI-specific base-layout and edit-buffer helpers |
+| `@opentui/keymap/extras`         | Pure config and formatting helpers                                         |
+| `@opentui/keymap/extras/graph`   | Graph snapshot helpers for debug and graph UIs                             |
+| `@opentui/keymap/testing`        | Host-agnostic fake host and diagnostics for addon tests                    |
+| `@opentui/keymap/opentui`        | OpenTUI host adapter for terminal apps built on `@opentui/core`            |
+| `@opentui/keymap/html`           | DOM host adapter for browser UIs rooted in an `HTMLElement`                |
+| `@opentui/keymap/react`          | React provider and hooks for an OpenTUI keymap                             |
+| `@opentui/keymap/solid`          | Solid provider and hooks for an OpenTUI keymap                             |
+
+Adapter entry points intentionally export adapter-specific helpers. Import the shared `Keymap`, stringifiers and core types from `@opentui/keymap`.
+
+## Bare vs default helpers
+
+| Helper                            | What it creates                                                                   |
+| --------------------------------- | --------------------------------------------------------------------------------- |
+| `new Keymap(host)`                | Bare keymap engine for a provided host                                            |
+| `createOpenTuiKeymap(renderer)`   | `Keymap` plus the OpenTUI host adapter                                            |
+| `createHtmlKeymap(root)`          | `Keymap` plus the HTML host adapter                                               |
+| `createDefaultOpenTuiKeymap(...)` | OpenTUI keymap plus default keys, enabled fields and metadata fields              |
+| `createDefaultHtmlKeymap(...)`    | HTML keymap plus default keys, enabled fields, metadata fields and event matching |
+
+The default helpers intentionally stay small. Leader tokens, ex commands, timed disambiguation, warning analyzers and OpenTUI textarea helpers are separate addons.
+
+## Next
+
+- [Hosts](/docs/keymap/hosts) explains the built-in host adapters and the `KeymapHost` contract.
+- [Core](/docs/keymap/core) documents the shared runtime, queries, intercepts and extension points.
+- [Built-in Addons](/docs/keymap/addons) covers the shipped addon packages.
+- [Custom Addons](/docs/keymap/custom-addons) covers the public addon-authoring APIs and extension-point constraints.
+- [Hosts](/docs/keymap/hosts), [React](/docs/keymap/react) and [Solid](/docs/keymap/solid) cover the built-in host and framework-specific surfaces.
diff --git a/.agents/skills/opentui/docs/keymap/react.mdx b/.agents/skills/opentui/docs/keymap/react.mdx
new file mode 100644
index 0000000..2022122
--- /dev/null
+++ b/.agents/skills/opentui/docs/keymap/react.mdx
@@ -0,0 +1,129 @@
+---
+title: React (OpenTUI)
+description: React provider and hooks for a pre-created OpenTUI keymap
+order: 4
+navTitle: React (OpenTUI)
+---
+
+# React keymap bindings (OpenTUI)
+
+This page covers `@opentui/keymap/react`.
+
+These bindings are for OpenTUI React apps. They consume a pre-created `Keymap<Renderable, KeyEvent>` from `@opentui/keymap/opentui`; they do not wrap the DOM/HTML adapter used in browser React apps.
+
+If you have not read the shared model yet, start with [Keymap overview](/docs/keymap/overview). For keymap construction, see [Keymap hosts](/docs/keymap/hosts).
+
+## What React adds
+
+- `KeymapProvider` - React context provider for an existing OpenTUI keymap
+- `useKeymap()` - returns the current OpenTUI keymap from context
+- `useBindings(createLayer, deps?)` - registers a keymap layer for the component lifecycle
+- `useActiveKeys(options?)` - derived active key list
+- `usePendingSequence()` - derived pending sequence
+- `reactiveMatcherFromStore(subscribe, getSnapshot, predicate?)` - adapts an external store to `ReactiveMatcher`
+
+## Basic usage
+
+```tsx
+/** @jsxImportSource @opentui/react */
+
+import { createCliRenderer } from "@opentui/core"
+import { createDefaultOpenTuiKeymap } from "@opentui/keymap/opentui"
+import { KeymapProvider, useBindings } from "@opentui/keymap/react"
+import { createRoot } from "@opentui/react"
+
+const renderer = await createCliRenderer()
+const keymap = createDefaultOpenTuiKeymap(renderer)
+
+function App() {
+  useBindings(
+    () => ({
+      commands: [
+        {
+          name: "quit",
+          run() {
+            renderer.destroy()
+          },
+        },
+      ],
+      bindings: [{ key: "q", cmd: "quit" }],
+    }),
+    [],
+  )
+
+  return <text>Press q to quit</text>
+}
+
+createRoot(renderer).render(
+  <KeymapProvider keymap={keymap}>
+    <App />
+  </KeymapProvider>,
+)
+```
+
+## Provider
+
+| Prop       | Type                           | Required | Description                 |
+| ---------- | ------------------------------ | -------- | --------------------------- |
+| `keymap`   | `Keymap<Renderable, KeyEvent>` | yes      | The OpenTUI keymap instance |
+| `children` | `ReactNode`                    | no       | Descendant React tree       |
+
+## Hooks
+
+| Hook                              | Description                                                                             |
+| --------------------------------- | --------------------------------------------------------------------------------------- |
+| `useKeymap()`                     | Returns the current keymap or throws if the provider is missing                         |
+| `useBindings(createLayer, deps?)` | Memoizes the layer factory with `deps`, registers the layer, and disposes it on unmount |
+| `useActiveKeys(options?)`         | Re-renders on batched keymap state changes and returns `getActiveKeys(...)`             |
+| `usePendingSequence()`            | Re-renders on batched keymap state changes and returns `getPendingSequence()`           |
+| `reactiveMatcherFromStore(...)`   | Builds a `ReactiveMatcher` from any subscribe/getSnapshot store                         |
+
+## `useBindings`
+
+`useBindings()` registers a layer-like object. The returned layer can include `priority`, `enabled`, `bindings`, `commands` and any custom addon fields.
+
+React memoizes `createLayer` with `useMemo(createLayer, deps)`. If you omit `deps`, the hook treats the layer factory as static after mount because the default is `[]`. If the layer shape depends on props or React state, include those values in `deps`.
+
+React-specific layer shapes:
+
+| Shape                      | Description                               |
+| -------------------------- | ----------------------------------------- |
+| Global layer               | Omit `targetRef`                          |
+| Local `focus-within` layer | Set `targetRef` and omit `targetMode`     |
+| Local exact-focus layer    | Set `targetRef` and `targetMode: "focus"` |
+
+- When `targetRef` is present and `targetMode` is omitted, `focus-within` is used.
+- If `targetRef.current` is `null`, registration waits until the ref resolves.
+- Passing a local `targetMode` without `targetRef` throws.
+- `deps` controls when the layer factory is re-evaluated.
+- Local layers follow `targetRef.current`, so they can wait for a ref to mount and retarget if that ref later points at a different renderable.
+
+## `useActiveKeys()` and `usePendingSequence()`
+
+```tsx
+const activeKeys = useActiveKeys({ includeMetadata: true })
+const pendingSequence = usePendingSequence()
+```
+
+Use these hooks for command palettes, key hint UIs, leader prompts and status bars.
+
+## `reactiveMatcherFromStore()`
+
+Use this when an addon field expects a `ReactiveMatcher`, for example the shipped `enabled` field:
+
+```tsx
+const matcher = useMemo(
+  () => reactiveMatcherFromStore(store.subscribe, store.getSnapshot, (mode) => mode === "normal"),
+  [store],
+)
+
+useBindings(
+  () => ({
+    enabled: matcher,
+    bindings: [{ key: "x", cmd: "delete-line" }],
+  }),
+  [matcher],
+)
+```
+
+Example: `packages/react/examples/keymap.tsx`
diff --git a/.agents/skills/opentui/docs/keymap/solid.mdx b/.agents/skills/opentui/docs/keymap/solid.mdx
new file mode 100644
index 0000000..3a9b021
--- /dev/null
+++ b/.agents/skills/opentui/docs/keymap/solid.mdx
@@ -0,0 +1,122 @@
+---
+title: Solid (OpenTUI)
+description: Solid provider and hooks for a pre-created OpenTUI keymap
+order: 5
+navTitle: Solid (OpenTUI)
+---
+
+# Solid keymap bindings (OpenTUI)
+
+This page covers `@opentui/keymap/solid`.
+
+These bindings are for OpenTUI Solid apps. They consume a pre-created `Keymap<Renderable, KeyEvent>` from `@opentui/keymap/opentui`; they do not wrap the DOM/HTML adapter used in browser Solid apps.
+
+If you have not read the shared model yet, start with [Keymap overview](/docs/keymap/overview). For keymap construction, see [Keymap hosts](/docs/keymap/hosts).
+
+## What Solid adds
+
+- `KeymapProvider` - Solid context provider for an existing OpenTUI keymap
+- `useKeymap()` - returns the current OpenTUI keymap from context
+- `useBindings(createLayer)` - registers a keymap layer for the current reactive scope
+- `useKeymapSelector(selector)` - reactively derives any value from the current keymap
+- `reactiveMatcherFromSignal(accessor, predicate?)` - adapts a Solid accessor to `ReactiveMatcher`
+
+## Basic usage
+
+```tsx
+import { createCliRenderer } from "@opentui/core"
+import { createDefaultOpenTuiKeymap } from "@opentui/keymap/opentui"
+import { KeymapProvider, useBindings } from "@opentui/keymap/solid"
+import { render } from "@opentui/solid"
+
+const renderer = await createCliRenderer()
+const keymap = createDefaultOpenTuiKeymap(renderer)
+
+function App() {
+  useBindings(() => ({
+    commands: [
+      {
+        name: "quit",
+        run() {
+          renderer.destroy()
+        },
+      },
+    ],
+    bindings: [{ key: "q", cmd: "quit" }],
+  }))
+
+  return <text>Press q to quit</text>
+}
+
+await render(
+  () => (
+    <KeymapProvider keymap={keymap}>
+      <App />
+    </KeymapProvider>
+  ),
+  renderer,
+)
+```
+
+## Provider
+
+| Prop       | Type                           | Required | Description                 |
+| ---------- | ------------------------------ | -------- | --------------------------- |
+| `keymap`   | `Keymap<Renderable, KeyEvent>` | yes      | The OpenTUI keymap instance |
+| `children` | `JSX.Element`                  | yes      | Descendant Solid tree       |
+
+## Hooks
+
+| Hook                             | Description                                                                                                       |
+| -------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `useKeymap()`                    | Returns the current keymap or throws if the provider is missing                                                   |
+| `useBindings(createLayer)`       | Runs the layer factory in a reactive effect, registers the layer, and disposes it with the current reactive scope |
+| `useKeymapSelector(selector)`    | Returns an `Accessor<T>` that re-runs the selector on batched keymap state changes                                |
+| `reactiveMatcherFromSignal(...)` | Builds a `ReactiveMatcher` from any Solid accessor                                                                |
+
+## `useBindings`
+
+`useBindings()` registers a layer-like object. The returned layer can include `priority`, `enabled`, `bindings`, `commands` and any custom addon fields.
+
+Solid runs `createLayer()` inside a reactive `createEffect`. Any tracked signals or memos you read inside the factory become dependencies, so the hook will unregister and re-register the layer when those values change. If the factory does not read reactive values, the layer stays stable.
+
+Solid-specific layer shapes:
+
+| Shape                      | Description                                     |
+| -------------------------- | ----------------------------------------------- |
+| Global layer               | Omit `target`                                   |
+| Local `focus-within` layer | Set `target` accessor and omit `targetMode`     |
+| Local exact-focus layer    | Set `target` accessor and `targetMode: "focus"` |
+
+- When `target` is present and `targetMode` is omitted, `focus-within` is used.
+- If the target accessor returns `null` or `undefined`, registration waits until it resolves.
+- Passing a local `targetMode` without `target` throws.
+
+## `useKeymapSelector()`
+
+`useKeymapSelector()` is the general derived-read API for Solid. It returns an `Accessor<T>`, so you read the current value by calling it:
+
+```tsx
+const activeKeys = useKeymapSelector((keymap) => keymap.getActiveKeys({ includeMetadata: true }))
+const pendingSequence = useKeymapSelector((keymap) => keymap.getPendingSequence())
+
+activeKeys()
+pendingSequence()
+```
+
+Use it for command palettes, key hint UIs, leader prompts, status bars, or any other derived keymap view.
+
+When the underlying host is destroyed mid-update, `useKeymapSelector()` returns the previous accessor value instead of throwing, so subscribers can render once more before their owner cleans up. The first read still throws if the host is already gone.
+
+## `reactiveMatcherFromSignal()`
+
+Use this when an addon field expects a `ReactiveMatcher`, for example the shipped `enabled` field:
+
+```tsx
+useBindings(() => ({
+  enabled: reactiveMatcherFromSignal(mode, (value) => value === "normal"),
+  bindings: [{ key: "x", cmd: "delete-line" }],
+}))
+```
+
+Example: `packages/solid/examples/components/keymap-demo.tsx`
diff --git a/.agents/skills/opentui/docs/plugins/core.mdx b/.agents/skills/opentui/docs/plugins/core.mdx
new file mode 100644
index 0000000..5db837c
--- /dev/null
+++ b/.agents/skills/opentui/docs/plugins/core.mdx
@@ -0,0 +1,245 @@
+---
+title: Core
+description: Framework-free slot hosting with BaseRenderable nodes
+order: 2
+---
+
+# Core slots
+
+This page shows the core host API for plugin slots.
+
+Use slots when you want external modules to render `BaseRenderable` UI in host-defined layout regions without forking the app. The host keeps control of layout and slot typing; plugins only render through the APIs you expose.
+
+If you have not read the shared model yet, start with [Plugin Slots](/docs/plugins/slots).
+
+## What core adds
+
+On top of `createSlotRegistry`, core provides:
+
+- `createCoreSlotRegistry` — create a registry typed for `BaseRenderable` nodes
+- `registerCorePlugin` — register a plugin using the core-specific `CorePlugin` interface
+- `SlotRenderable` — a `Renderable` that mounts a slot into the renderable tree
+- `resolveCoreSlot` — resolve slot entries without mounting
+- `@opentui/core/runtime-plugin-support` / `createRuntimePlugin` — runtime module support for external plugin/module loading in Bun
+
+Core slot renderers receive both the host context and slot data: `(ctx, data) => BaseRenderable`.
+
+`createCoreSlotRegistry` accepts the same [`SlotRegistryOptions`](/docs/plugins/slots#registry-options) as `createSlotRegistry`.
+
+## Runtime-loaded external plugins
+
+If your app loads plugin modules from disk at runtime, import this once in your app entry:
+
+```ts
+import "@opentui/core/runtime-plugin-support"
+```
+
+This installs Bun runtime support for `@opentui/core` plus default core runtime entrypoints (`@opentui/core/testing`). Add first-party package runtime modules explicitly when a plugin imports them.
+
+If you need additional host-resolved modules, configure runtime support before the side-effect import is loaded:
+
+```ts
+const { ensureRuntimePluginSupport } = await import("@opentui/core/runtime-plugin-support/configure")
+
+ensureRuntimePluginSupport({
+  additional: {
+    "my-runtime-module": { marker: "ok" },
+  },
+})
+```
+
+For plugins that import `@opentui/three`, install `@opentui/three` in the host app and pass its runtime module map:
+
+```ts
+import { runtimeModules as threeRuntimeModules } from "@opentui/three/runtime-modules"
+import { ensureRuntimePluginSupport } from "@opentui/core/runtime-plugin-support/configure"
+
+ensureRuntimePluginSupport({
+  additional: threeRuntimeModules,
+})
+```
+
+The side-effect import and configurable entrypoint install the same runtime plugin. Late additions throw with a clear error instead of being ignored.
+
+## `CorePlugin` interface
+
+| Field     | Type                                              | Required | Description                                                                                |
+| --------- | ------------------------------------------------- | -------- | ------------------------------------------------------------------------------------------ |
+| `id`      | `string`                                          | yes      | Unique identifier. Duplicate ids throw.                                                    |
+| `order`   | `number`                                          | no       | Sort priority (ascending). Defaults to `0`.                                                |
+| `setup`   | `(ctx, renderer) => void`                         | no       | Called once at registration time. If it throws, the plugin is not registered.              |
+| `dispose` | `() => void`                                      | no       | Called when the plugin is unregistered or the registry is cleared.                         |
+| `slots`   | `Partial<Record<SlotName, CoreSlotContribution>>` | yes      | Each value is a renderer function or a [managed slot object](#managed-slot-contributions). |
+
+A `CoreSlotContribution` is either a plain renderer `(ctx, data) => BaseRenderable` or a `CoreManagedSlot` with lifecycle hooks.
+
+## Basic usage
+
+A `SlotRenderable` extends `Renderable`, so it can be added to any parent like a `BoxRenderable`. It resolves plugins from the registry, manages their lifecycle, and reconciles their output as its children.
+
+```typescript
+import {
+  BoxRenderable,
+  createCliRenderer,
+  createCoreSlotRegistry,
+  registerCorePlugin,
+  SlotRenderable,
+  TextRenderable,
+} from "@opentui/core"
+
+type Slots = "statusbar"
+type SlotData = { label: string }
+const context = { appName: "core-app", version: "1.0.0" }
+
+const renderer = await createCliRenderer()
+
+const registry = createCoreSlotRegistry<Slots, typeof context, SlotData>(renderer, context)
+
+const unregister = registerCorePlugin(registry, {
+  id: "clock-plugin",
+  order: 0,
+  slots: {
+    statusbar(_ctx, data) {
+      return new TextRenderable(renderer, {
+        id: "clock-status",
+        content: `clock: ${data.label}`,
+      })
+    },
+  },
+})
+
+const slot = new SlotRenderable(renderer, {
+  id: "statusbar-slot",
+  registry,
+  name: "statusbar",
+  data: { label: "ok" },
+  mode: "append",
+  width: "100%",
+  height: 3,
+  flexDirection: "row",
+  fallback: () =>
+    new TextRenderable(renderer, {
+      id: "statusbar-fallback",
+      content: "fallback",
+    }),
+})
+
+renderer.root.add(slot)
+
+// later
+slot.mode = "replace"
+slot.data = { label: "updated" }
+slot.refresh()
+slot.destroy()
+```
+
+`registerCorePlugin` returns an unregister function (`() => void`). Calling it removes the plugin and invokes its `dispose` hook.
+
+Because `SlotRenderable` extends `Renderable`, it accepts all standard layout options (`width`, `height`, `flexDirection`, `padding`, etc.) alongside the slot-specific options.
+
+## `SlotRenderable` options
+
+| Option                     | Type                                                                | Required | Description                                                                                                |
+| -------------------------- | ------------------------------------------------------------------- | -------- | ---------------------------------------------------------------------------------------------------------- |
+| `id`                       | `string`                                                            | yes      | Unique renderable identifier (inherited from `RenderableOptions`)                                          |
+| `registry`                 | `CoreSlotRegistry`                                                  | yes      | The registry to read plugins from                                                                          |
+| `name`                     | slot name                                                           | yes      | Which slot to mount                                                                                        |
+| `data`                     | object                                                              | no       | Slot data passed to plugin renderers as the second argument                                                |
+| `mode`                     | `SlotMode`                                                          | no       | `"append"` (default), `"replace"`, or `"single_winner"`. See [slot modes](/docs/plugins/slots#slot-modes). |
+| `fallback`                 | `BaseRenderable \| BaseRenderable[] \| () => ...`                   | no       | Fallback nodes or a factory that creates them                                                              |
+| `pluginFailurePlaceholder` | `(failure, ctx) => BaseRenderable \| BaseRenderable[] \| undefined` | no       | Creates placeholder UI when a plugin throws                                                                |
+| _...layout options_        | `RenderableOptions`                                                 | no       | Standard layout props: `width`, `height`, `flexDirection`, `padding`, etc.                                 |
+
+## Instance API
+
+| Member      | Description                                                                                                                                                                                                                                                                                                                                                                                  |
+| ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mode`      | Getter/setter. Changing the mode automatically refreshes the slot.                                                                                                                                                                                                                                                                                                                           |
+| `refresh()` | Re-resolve plugins and reconcile mounted children.                                                                                                                                                                                                                                                                                                                                           |
+| `destroy()` | Inherits from `Renderable`. In addition to the standard cleanup, `SlotRenderable` unsubscribes from the registry, calls `onDeactivate` on active managed slots, then calls `onDispose` on all managed slots. Host-owned nodes (plain function contributions) are destroyed; plugin-owned nodes (managed slot contributions) are detached but left for the plugin to clean up in `onDispose`. |
+
+## `resolveCoreSlot`
+
+Resolve slot entries without mounting them. Useful when you need to inspect or render plugin output manually.
+
+```typescript
+import { createCliRenderer, createCoreSlotRegistry, resolveCoreSlot } from "@opentui/core"
+
+const renderer = await createCliRenderer()
+const registry = createCoreSlotRegistry<"statusbar">(renderer, {
+  appName: "core-app",
+  version: "1.0.0",
+})
+
+const entries = resolveCoreSlot(registry, "statusbar")
+// Array<{ id: string, renderer: (ctx, data) => BaseRenderable }>
+```
+
+## Plugin failure placeholders
+
+If a plugin throws during slot render, you can provide host-controlled fallback UI for that plugin failure:
+
+```typescript
+const slot = new SlotRenderable(renderer, {
+  registry,
+  name: "statusbar",
+  fallback: () => new TextRenderable(renderer, { id: "fallback", content: "fallback" }),
+  pluginFailurePlaceholder(failure, ctx) {
+    return new TextRenderable(renderer, {
+      id: `error-${failure.pluginId}`,
+      content: `plugin error: ${failure.pluginId}`,
+    })
+  },
+})
+```
+
+## Managed slot contributions
+
+A core slot contribution can be a plain function or a managed slot object with lifecycle hooks:
+
+```typescript
+registerCorePlugin(registry, {
+  id: "managed-plugin",
+  slots: {
+    statusbar: {
+      render(_ctx, data) {
+        return new TextRenderable(renderer, { id: "managed", content: "managed" })
+      },
+      onActivate(ctx) {
+        // plugin became active in this slot (visible)
+      },
+      onDeactivate(ctx) {
+        // plugin is no longer active (e.g. mode changed to single_winner and this plugin lost)
+      },
+      onDispose(ctx) {
+        // plugin is removed/disposed for this slot
+      },
+    },
+  },
+})
+```
+
+### `CoreManagedSlot` interface
+
+| Field          | Type                            | Required | Description                                                          |
+| -------------- | ------------------------------- | -------- | -------------------------------------------------------------------- |
+| `render`       | `(ctx, data) => BaseRenderable` | yes      | Creates the renderable node for this slot                            |
+| `onActivate`   | `(ctx) => void`                 | no       | Called when the plugin becomes active (visible) in the slot          |
+| `onDeactivate` | `(ctx) => void`                 | no       | Called when the plugin is no longer active (e.g. lost single_winner) |
+| `onDispose`    | `(ctx) => void`                 | no       | Called when the plugin is removed or the slot is destroyed           |
+
+### Node ownership
+
+When a slot contribution is a **plain function**, the host owns the returned nodes. On deactivation or disposal, the host detaches and destroys them.
+
+When a slot contribution is a **managed slot object**, the plugin owns the nodes. On deactivation the host detaches them but does _not_ destroy them — the plugin can reuse them if it becomes active again. On disposal, `onDispose` is called so the plugin can clean up.
+
+## Observability
+
+```typescript
+registry.onPluginError((event) => {
+  console.error(event.pluginId, event.phase, event.source, event.error.message)
+})
+```
+
+Example: `packages/examples/src/core-plugin-slots-demo.ts`
diff --git a/.agents/skills/opentui/docs/plugins/react.mdx b/.agents/skills/opentui/docs/plugins/react.mdx
new file mode 100644
index 0000000..987535b
--- /dev/null
+++ b/.agents/skills/opentui/docs/plugins/react.mdx
@@ -0,0 +1,154 @@
+---
+title: React
+description: React slot components backed by the shared plugin registry
+order: 3
+---
+
+# React slots
+
+This page shows React integration for plugin slots.
+
+Use slots when you want external modules to contribute `ReactNode` UI in host-defined regions without forking your app. The host keeps ownership of layout and slot typing; plugins only see the context and props you expose.
+
+If you have not read the shared model yet, start with [Plugin Slots](/docs/plugins/slots).
+
+## Runtime-loaded external plugins
+
+If your app loads plugins from disk at runtime (for example `await import(fileUrl)`), add this import once in your app entry:
+
+```ts
+import "@opentui/react/runtime-plugin-support"
+```
+
+This installs Bun runtime support so external TS/TSX plugin modules resolve against the host runtime instances (`@opentui/react`, React JSX runtime modules, and core runtime modules).
+
+Use this for plugin systems in both normal Bun runs and standalone compiled executables.
+
+```ts
+import "@opentui/react/runtime-plugin-support"
+
+const mod = await import(pathToFileURL(pluginPath).href)
+registry.register(mod.loadExternalPlugin())
+```
+
+If plugins need additional host-resolved modules, configure runtime support before the side-effect import is loaded:
+
+```ts
+import { ensureRuntimePluginSupport } from "@opentui/react/runtime-plugin-support/configure"
+
+ensureRuntimePluginSupport({
+  additional: {
+    "my-runtime-module": { marker: "ok" },
+  },
+})
+```
+
+First-party packages expose side-effect-free runtime module maps. For plugins that import `@opentui/three`, install `@opentui/three` in the host app and pass its runtime modules explicitly:
+
+```ts
+import { runtimeModules as threeRuntimeModules } from "@opentui/three/runtime-modules"
+import { ensureRuntimePluginSupport } from "@opentui/react/runtime-plugin-support/configure"
+
+ensureRuntimePluginSupport({
+  additional: threeRuntimeModules,
+})
+```
+
+The side-effect import and configurable entrypoint install the same runtime plugin. Late additions throw with a clear error instead of being ignored.
+
+## What React adds
+
+- `createReactSlotRegistry(renderer, context, options?)` — create a registry typed for `ReactNode`. Accepts the same [`SlotRegistryOptions`](/docs/plugins/slots#registry-options) as `createSlotRegistry`.
+- `Slot<TSlots, TContext>` — generic slot component that takes `registry` as a required prop
+- `createSlot(registry, options?)` — optional convenience helper that returns a registry-bound `<Slot />` component
+- `ReactPlugin<TSlots, TContext>` — convenience type alias for a plugin that returns `ReactNode`
+- `@opentui/react/runtime-plugin-support` — one-line runtime support for external plugin/module loading
+- `@opentui/react/runtime-plugin-support/configure` — configurable runtime support without import-time side effects
+
+Register plugins directly with `registry.register()` — no wrapper function is needed (unlike core's `registerCorePlugin`).
+
+## Basic usage
+
+```tsx
+import { createCliRenderer } from "@opentui/core"
+import { createReactSlotRegistry, createRoot, Slot } from "@opentui/react"
+
+type Slots = {
+  statusbar: { user: string }
+}
+
+const context = { appName: "react-app", version: "1.0.0" }
+const renderer = await createCliRenderer()
+
+const registry = createReactSlotRegistry<Slots, typeof context>(renderer, context)
+
+const unregister = registry.register({
+  id: "clock-plugin",
+  slots: {
+    statusbar(ctx, props) {
+      return <text>{`${ctx.appName}:${props.user}`}</text>
+    },
+  },
+})
+
+const AppSlot = Slot<Slots, typeof context>
+
+function App() {
+  return (
+    <AppSlot registry={registry} name="statusbar" user="sam" mode="replace">
+      <text>fallback-statusbar</text>
+    </AppSlot>
+  )
+}
+
+createRoot(renderer).render(<App />)
+```
+
+## Optional convenience helper
+
+If you prefer not to pass `registry` each time, you can still bind one once:
+
+```tsx
+const AppSlot = createSlot(registry)
+```
+
+## `<Slot>` props
+
+| Prop                       | Type                                       | Required | Description                                                                                                |
+| -------------------------- | ------------------------------------------ | -------- | ---------------------------------------------------------------------------------------------------------- |
+| `registry`                 | `SlotRegistry<ReactNode, Slots, Context>`  | yes      | Registry to resolve plugins from                                                                           |
+| `name`                     | `keyof Slots`                              | yes      | Which slot to render                                                                                       |
+| `mode`                     | `SlotMode`                                 | no       | `"append"` (default), `"replace"`, or `"single_winner"`. See [slot modes](/docs/plugins/slots#slot-modes). |
+| `pluginFailurePlaceholder` | `(failure: PluginErrorEvent) => ReactNode` | no       | Per-slot placeholder UI when a plugin throws                                                               |
+| `children`                 | `ReactNode`                                | no       | Fallback UI                                                                                                |
+| _remaining_                | `Slots[name]`                              | —        | Slot-specific props forwarded to plugin renderers                                                          |
+
+## `ReactSlotOptions` (for `createSlot`)
+
+| Option                     | Type                                       | Required | Description                                 |
+| -------------------------- | ------------------------------------------ | -------- | ------------------------------------------- |
+| `pluginFailurePlaceholder` | `(failure: PluginErrorEvent) => ReactNode` | no       | Creates placeholder UI when a plugin throws |
+
+## Plugin failure placeholders
+
+```tsx
+const Slot = createSlot(registry, {
+  pluginFailurePlaceholder(failure) {
+    return <text>{`plugin-error:${failure.pluginId}:${failure.phase}`}</text>
+  },
+})
+```
+
+If a plugin throws, the slot renders the placeholder. If no placeholder is provided (or it returns `null`), the slot falls back to `children`.
+
+Plugins that throw during the initial render call are caught inline. Plugins that throw during a React re-render are caught by an internal error boundary that resets on registry changes.
+
+## Observability
+
+```tsx
+registry.onPluginError((event) => {
+  console.error(event.pluginId, event.phase, event.source, event.error.message)
+})
+```
+
+Example: `packages/react/examples/plugin-slots-errors.tsx`
diff --git a/.agents/skills/opentui/docs/plugins/slots.mdx b/.agents/skills/opentui/docs/plugins/slots.mdx
new file mode 100644
index 0000000..fe5bbfe
--- /dev/null
+++ b/.agents/skills/opentui/docs/plugins/slots.mdx
@@ -0,0 +1,235 @@
+---
+title: Plugin Slots
+description: Shared slot registry API used by core, React, and Solid
+order: 1
+navTitle: Overview
+skill:
+  entry: true
+  intents: [plugins, plugin, slots, registry, extensions]
+---
+
+# Plugin slots
+
+Most TUI apps start as one codebase. As features and teams grow, you may want extension points without asking users to fork the app.
+
+Plugin slots give you that. The host application defines named places in the layout (for example, a status bar, sidebar, or panel), and plugins contribute UI for those places at runtime.
+
+The host stays in control of layout, rendering mode, and type contracts. Plugins only receive the context and slot props the host intentionally exposes.
+
+This page describes the **shared registry API** that the core, React, and Solid bindings are built on. If you are building an app, start with the page for the binding you use:
+
+- [Core slots](/docs/plugins/core) — framework-free, `BaseRenderable` nodes
+- [React slots](/docs/plugins/react) — `ReactNode`
+- [Solid slots](/docs/plugins/solid) — `JSX.Element`
+
+If you load plugin modules from disk at runtime, see the runtime support notes on the [React slots page](/docs/plugins/react#runtime-loaded-external-plugins) and [Solid slots page](/docs/plugins/solid#runtime-loaded-external-plugins). For custom hosts, use `@opentui/core/runtime-plugin-support` or `createRuntimePlugin` from `@opentui/core/runtime-plugin`.
+
+Read on if you need to understand the underlying model, want to build a custom binding for another framework, or need direct access to the registry API.
+
+## Concepts
+
+- **Host**: defines slot names and slot prop types.
+- **Plugin**: contributes one or more slot renderer callbacks. May include lifecycle hooks.
+- **Registry**: registers plugins and resolves contributions for a slot.
+- **Slot mode**: controls how plugin output and fallback UI combine (`append`, `replace`, or `single_winner`).
+
+## Define slots and host context
+
+Slot names map to the props each slot receives. The host context is a shared object passed to every plugin renderer.
+
+```typescript
+import type { PluginContext } from "@opentui/core"
+
+type AppSlots = {
+  statusbar: { user: string }
+  sidebar: { section: "left" | "right" }
+}
+
+interface AppContext extends PluginContext {
+  appName: string
+  version: string
+}
+```
+
+The context can be any object. `PluginContext` is a type alias for `object` — extending it is not required but gives your plugins a named type to reference.
+
+## Create a registry
+
+```typescript
+import { createSlotRegistry } from "@opentui/core"
+
+type AppSlots = {
+  statusbar: { user: string }
+  sidebar: { section: "left" | "right" }
+}
+
+const context = { appName: "my-app", version: "1.0.0" }
+
+const registry = createSlotRegistry<string, AppSlots, typeof context>(renderer, "my-app:plugins", context)
+```
+
+The first type parameter (`TNode`) is the node type your framework returns — `BaseRenderable` for core, `ReactNode` for React, `JSX.Element` for Solid. The framework-specific helpers fill this in for you.
+
+`createSlotRegistry` is renderer-scoped. For a given `(renderer, key)` pair, you always get the same registry instance. The `key` parameter namespaces registries within a renderer so multiple independent registries can coexist.
+
+Calling `createSlotRegistry` again with the same `(renderer, key)` pair returns the existing registry and applies the new `options` via `configure()`. The `context` argument **must** be the same object reference — passing a different context object throws an error. This means you should create the context object once and reuse it:
+
+```typescript
+// correct — same object reference
+const context = { appName: "my-app" }
+const reg1 = createSlotRegistry(renderer, "my-key", context)
+const reg2 = createSlotRegistry(renderer, "my-key", context) // returns reg1
+
+// throws — different object even if structurally identical
+const reg3 = createSlotRegistry(renderer, "my-key", { appName: "my-app" })
+```
+
+When the renderer is destroyed, all registries scoped to it are automatically cleared and disposed.
+
+The framework-specific helpers (`createCoreSlotRegistry`, `createReactSlotRegistry`, `createSolidSlotRegistry`) call `createSlotRegistry` internally with a fixed key. Use `createSlotRegistry` directly only if you need multiple independent registries per renderer.
+
+### Registry options
+
+All `create*SlotRegistry` functions accept an optional `SlotRegistryOptions` object:
+
+| Option              | Type                                | Default | Description                                                 |
+| ------------------- | ----------------------------------- | ------- | ----------------------------------------------------------- |
+| `onPluginError`     | `(event: PluginErrorEvent) => void` | —       | Callback invoked on every plugin error                      |
+| `debugPluginErrors` | `boolean`                           | `false` | When `true`, errors are also logged via `console.debug`     |
+| `maxPluginErrors`   | `number`                            | `100`   | Maximum number of buffered errors before oldest are dropped |
+
+## Register plugins
+
+```typescript
+const unregister = registry.register({
+  id: "clock-plugin",
+  order: 0,
+  setup(ctx, renderer) {
+    // called once on registration — initialize resources here
+  },
+  dispose() {
+    // called when the plugin is unregistered — clean up resources here
+  },
+  slots: {
+    statusbar(ctx, props) {
+      return `${ctx.appName}:${props.user}`
+    },
+  },
+})
+
+// later: remove this plugin
+unregister()
+```
+
+`register()` returns an unregister function. Calling it removes the plugin and invokes its `dispose` hook.
+
+### Plugin interface
+
+| Field     | Type                                    | Required | Description                                                                      |
+| --------- | --------------------------------------- | -------- | -------------------------------------------------------------------------------- |
+| `id`      | `string`                                | yes      | Unique identifier. Duplicate ids throw.                                          |
+| `order`   | `number`                                | no       | Sort priority (ascending). Defaults to `0`.                                      |
+| `setup`   | `(ctx, renderer) => void`               | no       | Called once at registration time. If it throws, the plugin is not registered.    |
+| `dispose` | `() => void`                            | no       | Called when the plugin is unregistered or the registry is cleared.               |
+| `slots`   | `{ [slotName]: (ctx, props) => TNode }` | yes      | Slot renderer callbacks. Each receives the host context and slot-specific props. |
+
+The core binding extends this with [managed slot objects](/docs/plugins/core#managed-slot-contributions) that add lifecycle hooks.
+
+### Ordering
+
+Plugins are resolved in this order:
+
+1. `order` ascending (lower numbers first)
+2. Registration order (earlier registrations first)
+3. `id` lexicographic (tie-breaker)
+
+## Slot modes
+
+Every slot mount or `<Slot>` component accepts a `mode`. The mode controls how plugin output and fallback UI combine.
+
+| Mode            | Behavior                                                                   |
+| --------------- | -------------------------------------------------------------------------- |
+| `append`        | Fallback first, then all plugin output (default)                           |
+| `replace`       | Plugin output only; fallback shown only when no plugins produce output     |
+| `single_winner` | Only the first plugin by resolved order; fallback if it produces no output |
+
+## Resolve contributions
+
+```typescript
+const entries = registry.resolveEntries("statusbar")
+// Array<{ id: string, renderer: (ctx, props) => TNode }>
+
+const slotRenderers = registry.resolve("statusbar")
+// Array<(ctx, props) => TNode>
+```
+
+`renderer` here means the plugin's **slot renderer callback**, not the `CliRenderer` instance.
+
+Use `resolveEntries` when you need plugin ids alongside the callbacks. Use `resolve` when you only need the callbacks.
+
+## Registry methods
+
+| Method                      | Description                                                                                                                 |
+| --------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| `register(plugin)`          | Add a plugin. Returns an unregister function.                                                                               |
+| `unregister(id)`            | Remove a plugin by id. Returns `true` if found.                                                                             |
+| `updateOrder(id, order)`    | Change a plugin's sort order. Returns `true` if found.                                                                      |
+| `clear()`                   | Remove and dispose all plugins.                                                                                             |
+| `resolve(slot)`             | Return ordered slot renderer callbacks.                                                                                     |
+| `resolveEntries(slot)`      | Return ordered `{ id, renderer }` entries.                                                                                  |
+| `subscribe(listener)`       | Listen for registration changes. Returns an unsubscribe function. Used internally by React and Solid to trigger re-renders. |
+| `configure(options)`        | Update `SlotRegistryOptions` after creation.                                                                                |
+| `onPluginError(listener)`   | Listen for plugin errors. Returns an unsubscribe function.                                                                  |
+| `getPluginErrors()`         | Return buffered `PluginErrorEvent` array.                                                                                   |
+| `clearPluginErrors()`       | Clear the error buffer.                                                                                                     |
+| `reportPluginError(report)` | Manually report a plugin error. Used by framework integrations.                                                             |
+| `renderer`                  | Getter — the `CliRenderer` this registry is scoped to.                                                                      |
+| `context`                   | Getter — the host context object.                                                                                           |
+
+## Error handling
+
+Registries expose plugin error events:
+
+```typescript
+registry.onPluginError((event) => {
+  console.error(event.pluginId, event.phase, event.source, event.error.message)
+})
+```
+
+You can also read and clear buffered errors:
+
+```typescript
+const history = registry.getPluginErrors()
+registry.clearPluginErrors()
+```
+
+### PluginErrorReport
+
+The `reportPluginError` method accepts a `PluginErrorReport`:
+
+| Field      | Type                  | Required | Description                                                  |
+| ---------- | --------------------- | -------- | ------------------------------------------------------------ |
+| `pluginId` | `string`              | yes      | The plugin that caused the error                             |
+| `slot`     | `string \| undefined` | no       | The slot name, if the error is slot-specific                 |
+| `phase`    | `PluginErrorPhase`    | yes      | `"setup"`, `"render"`, `"dispose"`, or `"error_placeholder"` |
+| `source`   | `PluginErrorSource`   | no       | Defaults to `"registry"` if omitted                          |
+| `error`    | `unknown`             | yes      | The raw error — normalized to `Error` internally             |
+
+### PluginErrorEvent
+
+| Field       | Type                  | Description                                                  |
+| ----------- | --------------------- | ------------------------------------------------------------ |
+| `pluginId`  | `string`              | The plugin that caused the error                             |
+| `slot`      | `string \| undefined` | The slot name, if the error is slot-specific                 |
+| `phase`     | `PluginErrorPhase`    | `"setup"`, `"render"`, `"dispose"`, or `"error_placeholder"` |
+| `source`    | `PluginErrorSource`   | `"registry"`, `"core"`, or a framework-defined source string |
+| `error`     | `Error`               | The normalized error object                                  |
+| `timestamp` | `number`              | `Date.now()` at the time of the error                        |
+
+## Next: concrete host APIs
+
+Use the shared model above with one of these host integrations:
+
+- [Core slots](/docs/plugins/core) — framework-free, returns `BaseRenderable` nodes
+- [React slots](/docs/plugins/react) — returns `ReactNode`
+- [Solid slots](/docs/plugins/solid) — returns `JSX.Element`
diff --git a/.agents/skills/opentui/docs/plugins/solid.mdx b/.agents/skills/opentui/docs/plugins/solid.mdx
new file mode 100644
index 0000000..b07a670
--- /dev/null
+++ b/.agents/skills/opentui/docs/plugins/solid.mdx
@@ -0,0 +1,163 @@
+---
+title: Solid
+description: Solid slot components backed by the shared plugin registry
+order: 4
+---
+
+# Solid slots
+
+This page shows Solid integration for plugin slots.
+
+Use slots when you want external modules to contribute `JSX.Element` UI in host-defined regions without forking your app. The host keeps ownership of layout and slot typing; plugins only see the context and props you expose.
+
+If you have not read the shared model yet, start with [Plugin Slots](/docs/plugins/slots).
+
+## Runtime-loaded external plugins
+
+If your app loads plugins from disk at runtime (for example `await import(fileUrl)`), add this import once in your app entry:
+
+```ts
+import "@opentui/solid/runtime-plugin-support"
+```
+
+This is a Bun drop-in that installs runtime transform support so external TS/TSX plugin modules use the same runtime instances as the host app (`@opentui/solid`, `@opentui/core`, `@opentui/core/testing`, `solid-js`, and `solid-js/store`). If a plugin imports another OpenTUI package, provide that package through `additional` runtime modules.
+
+Use this for plugin systems in both normal Bun runs and standalone compiled executables.
+
+```ts
+import "@opentui/solid/runtime-plugin-support"
+
+const mod = await import(pathToFileURL(pluginPath).href)
+registry.register(mod.loadExternalPlugin())
+```
+
+If plugins need additional host-resolved modules, configure runtime support before the side-effect import is loaded:
+
+```ts
+import { ensureRuntimePluginSupport } from "@opentui/solid/runtime-plugin-support/configure"
+
+ensureRuntimePluginSupport({
+  additional: {
+    "my-runtime-module": { marker: "ok" },
+  },
+})
+```
+
+First-party packages expose side-effect-free runtime module maps. For keymap-aware Solid plugins:
+
+```ts
+import { runtimeModules as keymapRuntimeModules } from "@opentui/keymap/runtime-modules"
+import { ensureRuntimePluginSupport } from "@opentui/solid/runtime-plugin-support/configure"
+
+ensureRuntimePluginSupport({
+  additional: keymapRuntimeModules,
+})
+```
+
+For plugins that import `@opentui/three`, install `@opentui/three` in the host app and pass its runtime modules explicitly:
+
+```ts
+import { runtimeModules as threeRuntimeModules } from "@opentui/three/runtime-modules"
+import { ensureRuntimePluginSupport } from "@opentui/solid/runtime-plugin-support/configure"
+
+ensureRuntimePluginSupport({
+  additional: threeRuntimeModules,
+})
+```
+
+The side-effect import and configurable entrypoint install the same runtime plugin. Late additions throw with a clear error instead of being ignored.
+
+## What Solid adds
+
+- `createSolidSlotRegistry(renderer, context, options?)` — create a registry typed for `JSX.Element`. Accepts the same [`SlotRegistryOptions`](/docs/plugins/slots#registry-options) as `createSlotRegistry`.
+- `Slot<TSlots, TContext>` — generic slot component that takes `registry` as a required prop
+- `createSlot(registry, options?)` — optional convenience helper that returns a registry-bound `<Slot />` component
+- `SolidPlugin<TSlots, TContext>` — convenience type alias for a plugin that returns `JSX.Element`
+- `@opentui/solid/runtime-plugin-support` — one-line runtime support for external plugin/module loading
+- `@opentui/solid/runtime-plugin-support/configure` — configurable runtime support without import-time side effects
+
+Register plugins directly with `registry.register()` — no wrapper function is needed (unlike core's `registerCorePlugin`).
+
+## Basic usage
+
+```tsx
+import { createCliRenderer } from "@opentui/core"
+import { createSolidSlotRegistry, Slot, render } from "@opentui/solid"
+
+type Slots = {
+  statusbar: { user: string }
+}
+
+const context = { appName: "solid-app", version: "1.0.0" }
+const renderer = await createCliRenderer()
+
+const registry = createSolidSlotRegistry<Slots, typeof context>(renderer, context)
+
+const unregister = registry.register({
+  id: "clock-plugin",
+  slots: {
+    statusbar(ctx, props) {
+      return <text>{`${ctx.appName}:${props.user}`}</text>
+    },
+  },
+})
+
+const AppSlot = Slot<Slots, typeof context>
+
+const App = () => (
+  <AppSlot registry={registry} name="statusbar" user="sam" mode="replace">
+    <text>fallback-statusbar</text>
+  </AppSlot>
+)
+
+render(() => <App />, renderer)
+```
+
+## Optional convenience helper
+
+If you prefer not to pass `registry` each time, you can still bind one once:
+
+```tsx
+const AppSlot = createSlot(registry)
+```
+
+## `<Slot>` props
+
+| Prop                       | Type                                         | Required | Description                                                                                                |
+| -------------------------- | -------------------------------------------- | -------- | ---------------------------------------------------------------------------------------------------------- |
+| `registry`                 | `SlotRegistry<JSX.Element, Slots, Context>`  | yes      | Registry to resolve plugins from                                                                           |
+| `name`                     | `keyof Slots`                                | yes      | Which slot to render                                                                                       |
+| `mode`                     | `SlotMode`                                   | no       | `"append"` (default), `"replace"`, or `"single_winner"`. See [slot modes](/docs/plugins/slots#slot-modes). |
+| `pluginFailurePlaceholder` | `(failure: PluginErrorEvent) => JSX.Element` | no       | Per-slot placeholder UI when a plugin throws                                                               |
+| `children`                 | `JSX.Element`                                | no       | Fallback UI                                                                                                |
+| _remaining_                | `Slots[name]`                                | —        | Slot-specific props forwarded to plugin renderers                                                          |
+
+## `SolidSlotOptions` (for `createSlot`)
+
+| Option                     | Type                                         | Required | Description                                 |
+| -------------------------- | -------------------------------------------- | -------- | ------------------------------------------- |
+| `pluginFailurePlaceholder` | `(failure: PluginErrorEvent) => JSX.Element` | no       | Creates placeholder UI when a plugin throws |
+
+## Plugin failure placeholders
+
+```tsx
+const Slot = createSlot(registry, {
+  pluginFailurePlaceholder(failure) {
+    return <text>{`plugin-error:${failure.pluginId}:${failure.phase}`}</text>
+  },
+})
+```
+
+If a plugin throws, the slot renders the placeholder. If no placeholder is provided (or it returns `null`), the slot falls back to `children`.
+
+Plugins that throw during the initial render call are caught inline. Plugins that throw during a Solid re-render are caught by an internal `<ErrorBoundary>` that reports the error to the registry.
+
+## Observability
+
+```tsx
+registry.onPluginError((event) => {
+  console.error(event.pluginId, event.phase, event.source, event.error.message)
+})
+```
+
+Example: `packages/solid/examples/components/plugin-slots-demo.tsx`
diff --git a/.agents/skills/opentui/docs/reference/color-matrix.mdx b/.agents/skills/opentui/docs/reference/color-matrix.mdx
new file mode 100644
index 0000000..d21a5ae
--- /dev/null
+++ b/.agents/skills/opentui/docs/reference/color-matrix.mdx
@@ -0,0 +1,160 @@
+---
+title: Color matrix
+description: Per-cell and uniform RGBA matrix transforms on FrameBuffer
+order: 3
+---
+
+# Color matrix
+
+`FrameBuffer` supports native 4x4 RGBA matrix transforms through two methods: `colorMatrix(...)` and
+`colorMatrixUniform(...)`.
+
+Use `colorMatrix(...)` when you want to transform specific cells with per-cell strengths. Use
+`colorMatrixUniform(...)` when you want to apply one transform to the entire buffer.
+
+Both methods work on normalized RGBA values (`0.0` to `1.0`) and can target foreground, background, or both channels.
+
+## API
+
+```typescript
+import { TargetChannel } from "@opentui/core"
+
+frameBuffer.colorMatrix(
+  matrix: Float32Array,
+  cellMask: Float32Array,
+  strength = 1.0,
+  target = TargetChannel.Both,
+)
+
+frameBuffer.colorMatrixUniform(
+  matrix: Float32Array,
+  strength = 1.0,
+  target = TargetChannel.Both,
+)
+```
+
+## Matrix format
+
+Matrix must be exactly 16 floats in row-major order.
+
+Each row defines one output channel:
+
+```text
+Row 0: [r->r, g->r, b->r, a->r]  // output red
+Row 1: [r->g, g->g, b->g, a->g]  // output green
+Row 2: [r->b, g->b, b->b, a->b]  // output blue
+Row 3: [r->a, g->a, b->a, a->a]  // output alpha
+```
+
+Each cell is transformed in two stages:
+
+```text
+newColor = M * color
+output = original + (newColor - original) * strength
+```
+
+This means `strength = 0.0` keeps original color, and `strength = 1.0` applies full matrix result.
+
+## Target channels
+
+Use the `TargetChannel` enum to choose which color buffers are affected:
+
+- `TargetChannel.FG` (`1`): foreground only
+- `TargetChannel.BG` (`2`): background only
+- `TargetChannel.Both` (`3`): foreground + background
+
+## `colorMatrix` cell mask format
+
+`cellMask` uses packed triplets:
+
+```text
+[x, y, perCellStrength, x, y, perCellStrength, ...]
+```
+
+- `x` and `y` are cell coordinates
+- `perCellStrength` is multiplied by method `strength`
+- incomplete trailing values (not a multiple of 3) are ignored
+- out-of-bounds or non-finite coordinates are skipped
+- non-finite effective strengths are skipped
+
+This method is useful for effects that only affect part of the buffer, such as scanlines, vignettes, or localized color
+grading.
+
+## `colorMatrixUniform` behavior
+
+`colorMatrixUniform` applies the same matrix to every pixel in the selected channel(s).
+
+- optimized path processes 4 pixels at a time with SIMD
+- scalar fallback handles any remaining pixels
+- `strength === 0` or non-finite `strength` returns early
+
+Use this method for full-frame color grading and global post-processing.
+
+## No clamping
+
+Result values are not clamped to `[0, 1]`. Matrix coefficients and strengths can push channels above `1.0` or below
+`0.0`.
+
+## Example: invert whole buffer
+
+```typescript
+import { INVERT_MATRIX, TargetChannel } from "@opentui/core"
+
+frameBuffer.colorMatrixUniform(INVERT_MATRIX, 1.0, TargetChannel.Both)
+```
+
+## Example: apply sepia to selected cells
+
+```typescript
+import { SEPIA_MATRIX, TargetChannel } from "@opentui/core"
+
+// Affect only three cells at custom strengths
+const cellMask = new Float32Array([
+  5,
+  2,
+  1.0, // full sepia at (5,2)
+  6,
+  2,
+  0.5, // half sepia at (6,2)
+  7,
+  2,
+  0.25, // subtle sepia at (7,2)
+])
+
+frameBuffer.colorMatrix(SEPIA_MATRIX, cellMask, 1.0, TargetChannel.FG)
+```
+
+## Example: custom saturation matrix
+
+```typescript
+import { TargetChannel } from "@opentui/core"
+
+function createSaturationMatrix(saturation: number): Float32Array {
+  const rw = 0.299
+  const gw = 0.587
+  const bw = 0.114
+  const inv = 1 - saturation
+
+  return new Float32Array([
+    rw * inv + saturation,
+    gw * inv,
+    bw * inv,
+    0,
+    rw * inv,
+    gw * inv + saturation,
+    bw * inv,
+    0,
+    rw * inv,
+    gw * inv,
+    bw * inv + saturation,
+    0,
+    0,
+    0,
+    0,
+    1,
+  ])
+}
+
+const saturation = createSaturationMatrix(1.25)
+frameBuffer.colorMatrixUniform(saturation, 0.8, TargetChannel.Both)
+```
diff --git a/.agents/skills/opentui/docs/reference/env-vars.mdx b/.agents/skills/opentui/docs/reference/env-vars.mdx
new file mode 100644
index 0000000..90aa66b
--- /dev/null
+++ b/.agents/skills/opentui/docs/reference/env-vars.mdx
@@ -0,0 +1,43 @@
+---
+title: Environment variables
+description: Runtime configuration flags for OpenTUI
+order: 1
+skill:
+  entry: true
+  intents: [env, environment, configuration, flags]
+---
+
+# Environment variables
+
+OpenTUI reads environment variables at runtime. Bun loads `.env` automatically, so you can set these in your shell or in a `.env` file.
+
+## Variables
+
+| Variable                       | Type      | Default | Description                                                   |
+| ------------------------------ | --------- | ------- | ------------------------------------------------------------- |
+| `OTUI_TS_STYLE_WARN`           | `string`  | `false` | Enable warnings for missing syntax styles                     |
+| `OTUI_TREE_SITTER_WORKER_PATH` | `string`  | `""`    | Path to the Tree-sitter worker                                |
+| `XDG_CONFIG_HOME`              | `string`  | `""`    | Base directory for user-specific configuration files          |
+| `XDG_DATA_HOME`                | `string`  | `""`    | Base directory for user-specific data files                   |
+| `OTUI_PALETTE_IDLE_TIMEOUT_MS` | `number`  | `300`   | Milliseconds of silence after palette queries before fallback |
+| `OTUI_DEBUG_FFI`               | `boolean` | `false` | Enable debug logging for the FFI bindings                     |
+| `OTUI_SHOW_STATS`              | `boolean` | `false` | Show the debug overlay at startup                             |
+| `OTUI_TRACE_FFI`               | `boolean` | `false` | Enable tracing for the FFI bindings                           |
+| `OPENTUI_FORCE_WCWIDTH`        | `boolean` | `false` | Use wcwidth for character width calculations                  |
+| `OPENTUI_FORCE_UNICODE`        | `boolean` | `false` | Force Mode 2026 Unicode support in terminal capabilities      |
+| `OPENTUI_GRAPHICS`             | `boolean` | `true`  | Enable Kitty graphics protocol detection                      |
+| `OPENTUI_FORCE_NOZWJ`          | `boolean` | `false` | Use no_zwj width method (Unicode without ZWJ joining)         |
+| `OPENTUI_FORCE_EXPLICIT_WIDTH` | `string`  | -       | Force explicit width detection (`true`/`1` or `false`/`0`)    |
+| `OTUI_USE_CONSOLE`             | `boolean` | `true`  | Enable global `console.*` capture for the built-in overlay    |
+| `SHOW_CONSOLE`                 | `boolean` | `false` | Open the built-in console overlay at startup                  |
+| `OTUI_DUMP_CAPTURES`           | `boolean` | `false` | Dump captured stdout and console caches from the exit handler |
+| `OTUI_NO_NATIVE_RENDER`        | `boolean` | `false` | Skip the Zig/native frame renderer                            |
+| `OTUI_DEBUG`                   | `boolean` | `false` | Capture all raw stdin input for debugging                     |
+
+## Notes
+
+- `OPENTUI_FORCE_EXPLICIT_WIDTH=false` skips OSC 66 queries on older terminals.
+- `OTUI_PALETTE_IDLE_TIMEOUT_MS` bounds palette detection when a terminal reports OSC support but does not answer follow-up color queries.
+- Disable global `console.*` capture with `OTUI_USE_CONSOLE=false`. `consoleMode` only changes the overlay surface.
+- `OTUI_NO_NATIVE_RENDER` still runs the render loop. In `"split-footer"` mode, the current stdout flush path can still emit ANSI cursor movement and clear sequences.
+- `OTUI_DUMP_CAPTURES` runs from the renderer exit handler. A direct `renderer.destroy()` call does not trigger it by itself.
diff --git a/.agents/skills/opentui/docs/reference/tree-sitter.mdx b/.agents/skills/opentui/docs/reference/tree-sitter.mdx
new file mode 100644
index 0000000..ad96f67
--- /dev/null
+++ b/.agents/skills/opentui/docs/reference/tree-sitter.mdx
@@ -0,0 +1,196 @@
+---
+title: Tree-sitter
+description: Add parsers and syntax highlighting with Tree-sitter
+order: 2
+---
+
+# Tree-sitter
+
+OpenTUI integrates Tree-sitter for fast, accurate syntax highlighting. You can register parsers globally or per client.
+
+## Add parsers globally
+
+Use `addDefaultParsers()` before creating clients:
+
+```typescript
+import { addDefaultParsers, getTreeSitterClient } from "@opentui/core"
+
+addDefaultParsers([
+  {
+    filetype: "python",
+    wasm: "https://github.com/tree-sitter/tree-sitter-python/releases/download/v0.23.6/tree-sitter-python.wasm",
+    queries: {
+      highlights: ["https://raw.githubusercontent.com/tree-sitter/tree-sitter-python/master/queries/highlights.scm"],
+    },
+  },
+])
+
+const client = getTreeSitterClient()
+await client.initialize()
+```
+
+## Add parsers per client
+
+```typescript
+import { TreeSitterClient } from "@opentui/core"
+
+const client = new TreeSitterClient({ dataPath: "./cache" })
+await client.initialize()
+
+client.addFiletypeParser({
+  filetype: "rust",
+  wasm: "https://github.com/tree-sitter/tree-sitter-rust/releases/download/v0.23.2/tree-sitter-rust.wasm",
+  queries: {
+    highlights: ["https://raw.githubusercontent.com/tree-sitter/tree-sitter-rust/master/queries/highlights.scm"],
+  },
+})
+```
+
+## Parser configuration
+
+```typescript
+interface FiletypeParserOptions {
+  filetype: string
+  aliases?: string[]
+  wasm: string
+  queries: {
+    highlights: string[]
+    injections?: string[]
+  }
+  injectionMapping?: {
+    nodeTypes?: Record<string, string>
+    infoStringMap?: Record<string, string>
+  }
+}
+```
+
+`aliases` maps additional filetype ids to the same parser assets.
+
+## Language injections
+
+Use `queries.injections` to highlight embedded languages.
+
+- `injectionMapping.nodeTypes` maps injected node types to filetype ids.
+- `injectionMapping.infoStringMap` maps code fence language labels to filetype ids.
+
+```typescript
+client.addFiletypeParser({
+  filetype: "markdown",
+  wasm: "https://github.com/tree-sitter-grammars/tree-sitter-markdown/releases/download/v0.5.1/tree-sitter-markdown.wasm",
+  queries: {
+    highlights: ["./assets/markdown/highlights.scm"],
+    injections: [
+      "https://raw.githubusercontent.com/nvim-treesitter/nvim-treesitter/refs/heads/master/queries/markdown/injections.scm",
+    ],
+  },
+  injectionMapping: {
+    nodeTypes: {
+      inline: "markdown_inline",
+      pipe_table_cell: "markdown_inline",
+    },
+    infoStringMap: {
+      js: "javascript",
+      jsx: "javascriptreact",
+      ts: "typescript",
+      tsx: "typescriptreact",
+    },
+  },
+})
+```
+
+If `infoStringMap` has no match, the fence language label is used as the filetype id.
+
+## Use local files
+
+```typescript
+import pythonWasm from "./parsers/tree-sitter-python.wasm" with { type: "file" }
+import pythonHighlights from "./queries/python/highlights.scm" with { type: "file" }
+
+addDefaultParsers([
+  {
+    filetype: "python",
+    wasm: pythonWasm,
+    queries: {
+      highlights: [pythonHighlights],
+    },
+  },
+])
+```
+
+## Automated asset management
+
+Use the `updateAssets` utility to download parsers and generate imports.
+
+### CLI usage
+
+```json
+{
+  "scripts": {
+    "prebuild": "bun node_modules/@opentui/core/lib/tree-sitter/assets/update.ts --config ./parsers-config.json --assets ./src/parsers --output ./src/parsers.ts"
+  }
+}
+```
+
+### Programmatic usage
+
+```typescript
+import { updateAssets } from "@opentui/core"
+
+await updateAssets({
+  configPath: "./parsers-config.json",
+  assetsDir: "./src/parsers",
+  outputPath: "./src/parsers.ts",
+})
+```
+
+## Using with CodeRenderable
+
+```typescript
+import { CodeRenderable, RGBA, SyntaxStyle, getTreeSitterClient } from "@opentui/core"
+
+const client = getTreeSitterClient()
+await client.initialize()
+
+const syntaxStyle = SyntaxStyle.fromStyles({
+  default: { fg: RGBA.fromHex("#E6EDF3") },
+})
+
+const code = new CodeRenderable(renderer, {
+  id: "code",
+  content: "const x = 1",
+  filetype: "typescript",
+  syntaxStyle,
+  treeSitterClient: client,
+})
+```
+
+## Caching
+
+Parser and query files are cached in the client `dataPath`. Set a custom cache directory:
+
+```typescript
+const client = new TreeSitterClient({
+  dataPath: "./my-cache",
+})
+```
+
+## File type resolution
+
+```typescript
+import { pathToFiletype, extToFiletype, infoStringToFiletype } from "@opentui/core"
+
+const ft1 = pathToFiletype("src/main.rs")
+const ft2 = extToFiletype("ts")
+const ft3 = infoStringToFiletype("TSX title=Button.tsx")
+```
+
+`infoStringToFiletype()` is used for fenced markdown code blocks.
+
+You can extend or override mappings at runtime:
+
+```typescript
+import { extensionToFiletype, basenameToFiletype } from "@opentui/core"
+
+extensionToFiletype.set("templ", "html")
+basenameToFiletype.set("mytoolrc", "yaml")
+```
diff --git a/.github/actions/setup-go/action.yml b/.github/actions/setup-go/action.yml
deleted file mode 100644
index 480f40f..0000000
--- a/.github/actions/setup-go/action.yml
+++ /dev/null
@@ -1,29 +0,0 @@
-name: Setup Go
-description: 'Sets up Go environment with private modules'
-inputs:
-  stainless-api-key:
-    required: false
-    description: the value of the STAINLESS_API_KEY secret
-runs:
-  using: composite
-  steps:
-    - uses: stainless-api/retrieve-github-access-token@v1
-      if: github.repository == 'stainless-sdks/beeper-desktop-api-cli'
-      id: get_token
-      with:
-        repo: stainless-sdks/beeper-desktop-api-go
-        stainless-api-key: ${{ inputs.stainless-api-key }}
-
-    - name: Configure Git for access to the Go SDK's staging repo
-      if: github.repository == 'stainless-sdks/beeper-desktop-api-cli'
-      shell: bash
-      run: git config --global url."https://x-access-token:${{ steps.get_token.outputs.github_access_token }}@github.com/stainless-sdks/beeper-desktop-api-go".insteadOf "https://github.com/stainless-sdks/beeper-desktop-api-go"
-
-    - name: Setup go
-      uses: actions/setup-go@v5
-      with:
-        go-version-file: ./go.mod
-
-    - name: Bootstrap
-      shell: bash
-      run: ./scripts/bootstrap
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2742613..582bbfc 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,115 +2,39 @@ name: CI
 on:
   push:
     branches:
-      - '**'
-      - '!integrated/**'
-      - '!stl-preview-head/**'
-      - '!stl-preview-base/**'
-      - '!generated'
-      - '!codegen/**'
-      - 'codegen/stl/**'
+      - "**"
+      - "!integrated/**"
+      - "!stl-preview-head/**"
+      - "!stl-preview-base/**"
+      - "!generated"
+      - "!codegen/**"
+      - "codegen/stl/**"
   pull_request:
     branches-ignore:
-      - 'stl-preview-head/**'
-      - 'stl-preview-base/**'
-
-env:
-  GOPRIVATE: github.com/beeper/desktop-api-go,github.com/stainless-sdks/beeper-desktop-api-go
+      - "stl-preview-head/**"
+      - "stl-preview-base/**"
 
 jobs:
-  lint:
-    timeout-minutes: 10
-    name: lint
-    runs-on: ${{ github.repository == 'stainless-sdks/beeper-desktop-api-cli' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
-    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork
-
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: ./.github/actions/setup-go
-        with:
-          stainless-api-key: ${{ secrets.STAINLESS_API_KEY }}
-
-      - name: Link staging branch
-        if: github.repository == 'stainless-sdks/beeper-desktop-api-cli'
-        run: |
-          ./scripts/link 'github.com/stainless-sdks/beeper-desktop-api-go@${{ github.ref_name }}' || true
-
-      - name: Bootstrap
-        run: ./scripts/bootstrap
-
-      - name: Run lints
-        run: ./scripts/lint
-
-  build:
-    timeout-minutes: 10
-    name: build
-    permissions:
-      contents: read
-      id-token: write
-    runs-on: ${{ github.repository == 'stainless-sdks/beeper-desktop-api-cli' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
-    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: ./.github/actions/setup-go
-        with:
-          stainless-api-key: ${{ secrets.STAINLESS_API_KEY }}
-
-      - name: Link staging branch
-        if: github.repository == 'stainless-sdks/beeper-desktop-api-cli'
-        run: |
-          ./scripts/link 'github.com/stainless-sdks/beeper-desktop-api-go@${{ github.ref_name }}' || true
-
-      - name: Bootstrap
-        run: ./scripts/bootstrap
-
-      - name: Run goreleaser
-        uses: goreleaser/goreleaser-action@v6.1.0
-        with:
-          version: latest
-          args: release --snapshot --clean --skip=publish
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Get GitHub OIDC Token
-        if: |-
-          github.repository == 'stainless-sdks/beeper-desktop-api-cli' &&
-          !startsWith(github.ref, 'refs/heads/stl/')
-        id: github-oidc
-        uses: actions/github-script@v8
-        with:
-          script: core.setOutput('github_token', await core.getIDToken());
-
-      - name: Upload tarball
-        if: |-
-          github.repository == 'stainless-sdks/beeper-desktop-api-cli' &&
-          !startsWith(github.ref, 'refs/heads/stl/')
-        env:
-          URL: https://pkg.stainless.com/s
-          AUTH: ${{ steps.github-oidc.outputs.github_token }}
-          SHA: ${{ github.sha }}
-        run: ./scripts/utils/upload-artifact.sh
-
   test:
     timeout-minutes: 10
     name: test
-    runs-on: ${{ github.repository == 'stainless-sdks/beeper-desktop-api-cli' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
-    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
 
-      - uses: ./.github/actions/setup-go
+      - uses: actions/setup-node@v6
         with:
-          stainless-api-key: ${{ secrets.STAINLESS_API_KEY }}
+          node-version: 24
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
 
-      - name: Link staging branch
-        if: github.repository == 'stainless-sdks/beeper-desktop-api-cli'
-        run: |
-          ./scripts/link 'github.com/stainless-sdks/beeper-desktop-api-go@${{ github.ref_name }}' || true
+      - name: Typecheck
+        run: npm run typecheck
 
-      - name: Bootstrap
-        run: ./scripts/bootstrap
+      - name: Test
+        run: npm test
 
-      - name: Run tests
-        run: ./scripts/test
+      - name: Package Homebrew archive
+        run: npm run pack:homebrew
diff --git a/.github/workflows/publish-release.yml b/.github/workflows/publish-release.yml
index 4e556fb..4a8b38e 100644
--- a/.github/workflows/publish-release.yml
+++ b/.github/workflows/publish-release.yml
@@ -2,6 +2,7 @@
 name: Publish Release
 permissions:
   contents: write
+  id-token: write
 
 concurrency:
   group: publish
@@ -11,27 +12,35 @@ on:
     tags:
       - "v*"
 jobs:
-  goreleaser:
+  publish:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
       uses: actions/checkout@v6
       with:
         fetch-depth: 0
-    - name: Set up Go
-      uses: actions/setup-go@v5
+    - name: Set up Node
+      uses: actions/setup-node@v6
       with:
-        go-version-file: "go.mod"
-    - name: Run GoReleaser
-      uses: goreleaser/goreleaser-action@v6.1.0
-      with:
-        version: latest
-        args: release --clean
+        node-version: 24
+        cache: npm
+    - name: Install dependencies
+      run: npm ci
+    - name: Test
+      run: npm test
+    - name: Build Homebrew archive
+      run: npm run pack:homebrew
+    - name: Publish GitHub release assets
+      env:
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        set -euo pipefail
+        tag="${GITHUB_REF_NAME}"
+        if ! gh release view "${tag}" >/dev/null 2>&1; then
+          gh release create "${tag}" --title "${tag}" --generate-notes --verify-tag
+        fi
+        gh release upload "${tag}" dist/release/*.tar.gz dist/release/homebrew.json --clobber
+    - name: Publish Homebrew formula
       env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         HOMEBREW_TAP_GITHUB_TOKEN: ${{ secrets.HOMEBREW_TAP_GITHUB_TOKEN }}
-        MACOS_SIGN_P12: ${{ secrets.MACOS_SIGN_P12 }}
-        MACOS_SIGN_PASSWORD: ${{ secrets.MACOS_SIGN_PASSWORD }}
-        MACOS_NOTARY_ISSUER_ID: ${{ secrets.MACOS_NOTARY_ISSUER_ID }}
-        MACOS_NOTARY_KEY_ID: ${{ secrets.MACOS_NOTARY_KEY_ID }}
-        MACOS_NOTARY_KEY: ${{ secrets.MACOS_NOTARY_KEY }}
\ No newline at end of file
+      run: node scripts/publish-homebrew-formula.mjs
diff --git a/.gitignore b/.gitignore
index 268ede0..cadd9eb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 .prism.log
 .stdy.log
 dist/
+node_modules/
 /beeper-desktop-cli
 *.exe
diff --git a/.goreleaser.yml b/.goreleaser.yml
deleted file mode 100644
index b418408..0000000
--- a/.goreleaser.yml
+++ /dev/null
@@ -1,110 +0,0 @@
-project_name: beeper-desktop-cli
-version: 2
-
-before:
-  hooks:
-    - mkdir -p completions
-    - sh -c "go run ./cmd/beeper-desktop-cli/main.go @completion bash > completions/beeper-desktop-cli.bash"
-    - sh -c "go run ./cmd/beeper-desktop-cli/main.go @completion zsh > completions/beeper-desktop-cli.zsh"
-    - sh -c "go run ./cmd/beeper-desktop-cli/main.go @completion fish > completions/beeper-desktop-cli.fish"
-    - sh -c "go run ./cmd/beeper-desktop-cli/main.go @manpages -o man"
-
-builds:
-  - id: macos
-    goos: [darwin]
-    goarch: [amd64, arm64]
-    binary: '{{ .ProjectName }}'
-    main: ./cmd/beeper-desktop-cli/main.go
-    mod_timestamp: '{{ .CommitTimestamp }}'
-    ldflags:
-      - '-s -w -X main.version={{.Version}} -X main.commit={{.Commit}}'
-
-  - id: linux
-    goos: [linux]
-    goarch: ['386', arm, amd64, arm64]
-    env:
-      - CGO_ENABLED=0
-    binary: '{{ .ProjectName }}'
-    main: ./cmd/beeper-desktop-cli/main.go
-    mod_timestamp: '{{ .CommitTimestamp }}'
-    ldflags:
-      - '-s -w -X main.version={{.Version}} -X main.commit={{.Commit}}'
-
-  - id: windows
-    goos: [windows]
-    goarch: ['386', amd64, arm64]
-    binary: '{{ .ProjectName }}'
-    main: ./cmd/beeper-desktop-cli/main.go
-    mod_timestamp: '{{ .CommitTimestamp }}'
-    ldflags:
-      - '-s -w -X main.version={{.Version}} -X main.commit={{.Commit}}'
-
-archives:
-  - id: linux-archive
-    ids: [linux]
-    name_template: '{{ .ProjectName }}_{{ .Version }}_linux_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}'
-    formats: [tar.gz]
-    files:
-      - completions/*
-      - man/*/*
-  - id: macos-archive
-    ids: [macos]
-    name_template: '{{ .ProjectName }}_{{ .Version }}_macos_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}'
-    formats: [zip]
-    files:
-      - completions/*
-      - man/*/*
-  - id: windows-archive
-    ids: [windows]
-    name_template: '{{ .ProjectName }}_{{ .Version }}_windows_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}'
-    formats: [zip]
-    files:
-      - completions/*
-      - man/*/*
-
-snapshot:
-  version_template: '{{ .Tag }}-next'
-
-nfpms:
-  - license: MIT
-    maintainer: help@beeper.com
-    bindir: /usr
-    formats:
-      - apk
-      - deb
-      - rpm
-      - termux.deb
-      - archlinux
-    contents:
-      - src: man/man1/*.1.gz
-        dst: /usr/share/man/man1/
-homebrew_casks:
-  - name: beeper-desktop-cli
-    repository:
-      owner: beeper
-      name: homebrew-tap
-      token: "{{ .Env.HOMEBREW_TAP_GITHUB_TOKEN }}"
-    homepage: https://developers.beeper.com/desktop-api/
-    description: CLI for Beeper Desktop API
-    license: MIT
-    binary: "beeper-desktop-cli"
-    completions:
-      bash: "completions/beeper-desktop-cli.bash"
-      zsh: "completions/beeper-desktop-cli.zsh"
-      fish: "completions/beeper-desktop-cli.fish"
-    manpages:
-    - man/man1/beeper-desktop-cli.1.gz
-
-notarize:
-  macos:
-    - enabled: '{{ isEnvSet "MACOS_SIGN_P12" }}'
-      ids: [macos]
-
-      sign:
-        certificate: "{{.Env.MACOS_SIGN_P12}}"
-        password: "{{.Env.MACOS_SIGN_PASSWORD}}"
-
-      notarize:
-        issuer_id: "{{.Env.MACOS_NOTARY_ISSUER_ID}}"
-        key_id: "{{.Env.MACOS_NOTARY_KEY_ID}}"
-        key: "{{.Env.MACOS_NOTARY_KEY}}"
diff --git a/README.md b/README.md
index 09e97fb..352174d 100644
--- a/README.md
+++ b/README.md
@@ -1,121 +1,1792 @@
-# Beeper Desktop CLI
+# Beeper CLI
 
-The official CLI for the [Beeper Desktop REST API](https://developers.beeper.com/desktop-api/).
+Command-line access to the [Beeper Desktop API](https://developers.beeper.com/desktop-api/).
 
-It is generated with [Stainless](https://www.stainless.com/).
+The CLI is built with TypeScript, oclif, and the official `@beeper/desktop-api`
+SDK. The command reference below is generated from the oclif command metadata in
+the built CLI.
 
-<!-- x-release-please-start-version -->
+## Install
 
-## Installation
+Beeper CLI is distributed through Homebrew as a built release archive:
 
-### Installing with Homebrew
+```sh
+brew install beeper/tap/beeper-cli
+```
+
+The installed command is `beeper`.
+
+## Local Development
+
+```sh
+npm install
+npm run build
+node ./bin/run.js --help
+```
+
+Run commands directly from TypeScript:
+
+```sh
+npm run dev -- --help
+```
+
+Regenerate this README after command, flag, or argument changes:
+
+```sh
+npm run readme
+```
+
+## Authenticate
+
+```sh
+beeper chats
+beeper auth status
+```
+
+On first use, authenticated commands look for a local Beeper Desktop API on the
+default port range. If Beeper Desktop is already signed in, the CLI immediately
+uses OAuth2 Authorization Code with PKCE and stores the server URL and bearer
+token in `~/.config/beeper/config.json`. After that, commands reuse the
+remembered server URL.
+
+If the local Desktop app is not authenticated, the CLI exits with an error
+instead of starting another login flow. You can explicitly sign in the app
+itself with:
+
+```sh
+beeper login --app-login --email you@example.com
+```
+
+For non-interactive use, pass a token through the environment:
+
+```sh
+BEEPER_ACCESS_TOKEN=... beeper chats --json
+```
+
+## Common Workflows
+
+```sh
+beeper doctor
+beeper status
+beeper accounts
+beeper chats
+beeper messages "Family"
+beeper send "Family" "on my way" --wait
+beeper export --out ./beeper-export
+beeper api get /v1/info
+```
+
+## Input Resolution
+
+- Chat arguments accept Beeper chat IDs, local chat IDs, exact titles, or search text.
+- Ambiguous chat matches return numbered choices; pass `--pick N` to select one.
+- Account arguments accept account IDs, network names, bridge type/id, or account user identity.
+- Account filters can expand a network name to multiple matching accounts.
+- `contacts search` and `start-chat` can search across all accounts when `--account` is omitted.
+- `contacts list` accepts the same account selectors as other account-scoped commands.
+
+## Output
+
+Most commands support:
+
+- app-like text by default, optimized for scanning chats, messages, contacts, accounts, and assets
+- `--json` for exact API-shaped structured output
+- `--debug` for SDK debug logging
+- `--base-url` to point at a different local Desktop API server
+
+Use `beeper login --server-url URL` to remember a Desktop API server URL for
+future commands.
+
+`commands --json` prints a compact command manifest for tools and agents.
+`llm` prints a concise human-readable command guide.
+
+## Environment
+
+| Environment variable | Description |
+| --- | --- |
+| `BEEPER_ACCESS_TOKEN` | Bearer token. Overrides stored OAuth login. |
+| `BEEPER_DESKTOP_BASE_URL` | Beeper Desktop API base URL. Defaults to `http://localhost:23373`. |
+| `BEEPER_BASE_URL` | SDK-compatible base URL fallback. |
+| `BEEPER_CLI_CONFIG_DIR` | Override config directory for testing or isolated profiles. |
+
+## Command Summary
+
+| Command | Summary |
+| --- | --- |
+| `accounts` | List Chat Accounts connected to this Beeper Desktop instance, including bridge metadata and network identity. |
+| `accounts add` | Add a Beeper account |
+| `api get` | Call a raw Desktop API GET path |
+| `api post` | Call a raw Desktop API POST path with a JSON body |
+| `app e2ee recovery-code mark-backed-up` | Mark the recovery key as saved |
+| `app e2ee recovery-code reset begin` | Create a new recovery key |
+| `app e2ee recovery-code reset confirm` | Confirm a newly created recovery key |
+| `app e2ee recovery-code verify` | Unlock encrypted messages with a recovery key |
+| `app e2ee verification accept` | Accept a device verification request |
+| `app e2ee verification cancel` | Cancel device verification |
+| `app e2ee verification qr confirm-scanned` | Confirm another device scanned this QR code |
+| `app e2ee verification qr scan` | Submit a scanned verification QR payload |
+| `app e2ee verification sas confirm` | Confirm matching emoji verification |
+| `app e2ee verification sas start` | Start emoji verification |
+| `app e2ee verification start` | Start device verification |
+| `app status` | Show Beeper app login and encrypted messaging state |
+| `archive` | Archive or unarchive a chat. Set archived=true to move to archive, archived=false to move back to inbox |
+| `assets download` | Download a Matrix file using its mxc:// or localmxc:// URL to the device running Beeper Desktop and return the local file URL. |
+| `assets upload` | Upload a file to a temporary location using multipart/form-data. Returns an uploadID that can be referenced when sending a message or materializing a draft attachment. |
+| `auth login` | Authenticate with local Beeper Desktop |
+| `auth logout` | Remove the locally stored Beeper Desktop token |
+| `auth status` | Show local auth status and token metadata |
+| `autocomplete` | Display autocomplete installation instructions. |
+| `avatar` | Set or clear a group chat avatar |
+| `chat` | Retrieve chat details including metadata, participants, and latest message |
+| `chat open` | Focus Beeper Desktop, optionally opening a chat or message |
+| `chats` | List all chats sorted by last activity (most recent first). Combines all accounts into a single paginated list. |
+| `chats search` | Search chats by title, network, or participant names. |
+| `clear-draft` | Clear a chat draft |
+| `commands` | Print the Beeper CLI command manifest |
+| `config get` | Print CLI configuration |
+| `config path` | Print the CLI config path |
+| `config reset` | Reset CLI configuration |
+| `config set` | Set a CLI configuration value |
+| `contacts list` | List merged contacts for a specific account with cursor-based pagination. |
+| `contacts search` | Search contacts on a specific account using merged account contacts, network search, and exact identifier lookup. |
+| `create-chat` | Create a direct or group chat from participant IDs. Returns the created chat. |
+| `current-user` | Show the authenticated Desktop API user |
+| `delete-message` | Delete a message by final message ID. Pending message IDs are not accepted because messages cannot be deleted while sending. |
+| `description` | Set or clear a group chat description |
+| `doctor` | Verify Desktop API reachability and authentication |
+| `draft` | Set a chat draft |
+| `edit` | Edit the text content of an existing message. Messages with attachments cannot be edited. |
+| `export` | Export accounts, chats, messages, Markdown transcripts, and attachments. |
+| `focus` | Focus Beeper Desktop, optionally opening a chat or message |
+| `help` | Display help for beeper. |
+| `inbox` | Move a chat to the primary inbox |
+| `llm` | Print compact CLI help for agents |
+| `login` | Authenticate with local Beeper Desktop |
+| `logout` | Remove the locally stored Beeper Desktop token |
+| `low-priority` | Move a chat to Low Priority |
+| `mark-read` | Mark a chat as read, optionally through a specific message ID. |
+| `mark-unread` | Mark a chat as unread, optionally from a specific message ID. |
+| `message` | Retrieve a message by final message ID, pendingMessageID, or Matrix event ID. Chat ID may be a Beeper chat ID or local chat ID. |
+| `message-expiry` | Set or clear disappearing-message expiry |
+| `messages` | List all messages in a chat with cursor-based pagination. Sorted by timestamp. |
+| `messages search` | Search messages across chats. |
+| `mute` | Mute a chat |
+| `notify-anyway` | Force a delivery notification when supported by the underlying network. Currently intended for iMessage on macOS; unsupported networks return an error. |
+| `pin` | Pin a chat |
+| `react` | Add a reaction to an existing message. |
+| `read` | Mark a chat as read, optionally through a specific message ID. |
+| `remind` | Set a reminder for a chat at a specific time |
+| `reply` | Send a text message to a specific chat. Supports replying to existing messages. Returns a pending message ID. |
+| `reply-file` | Send a text message to a specific chat. Supports replying to existing messages. Returns a pending message ID. |
+| `rpc` | Run newline-delimited JSON command RPC |
+| `search` | Search chats and messages |
+| `send` | Send a text message to a specific chat. Supports replying to existing messages. Returns a pending message ID. |
+| `send-file` | Send a text message to a specific chat. Supports replying to existing messages. Returns a pending message ID. |
+| `shell` | Run an interactive Beeper CLI shell |
+| `start-chat` | Resolve a user/contact and open a direct chat. Reuses and returns an existing direct chat when one is found. Available in Beeper Desktop v4.2.808+. |
+| `status` | Check Beeper Desktop API status |
+| `tail` | Stream Desktop API WebSocket events |
+| `thread` | Retrieve chat details including metadata, participants, and latest message |
+| `threads` | List all chats sorted by last activity (most recent first). Combines all accounts into a single paginated list. |
+| `title` | Set a custom chat title |
+| `unarchive` | Archive or unarchive a chat. Set archived=true to move to archive, archived=false to move back to inbox |
+| `unmute` | Unmute a chat |
+| `unpin` | Unpin a chat |
+| `unreact` | Remove the reaction added by the authenticated user from an existing message. |
+| `unread` | Mark a chat as unread, optionally from a specific message ID. |
+| `unremind` | Clear an existing reminder from a chat |
+| `watch` | Stream Desktop API WebSocket events |
+| `whoami` | Show the authenticated Desktop API user |
+
+## Command Reference
+
+### `beeper accounts`
+List Chat Accounts connected to this Beeper Desktop instance, including bridge metadata and network identity.
+
+```sh
+beeper accounts
+```
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper accounts add`
+Add a Beeper account
+
+```sh
+beeper accounts add [account]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `account` | no | Account type to add, for example WhatsApp, Discord, or local-whatsapp |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--cookie=<value>...` | option | Cookie value for non-interactive login, in name=value form. Repeat for multiple cookies. |
+| `--field=<value>...` | option | Field value for non-interactive login, in id=value form. Repeat for multiple fields. |
+| `--flow=<value>` | option | Login flow ID. If omitted, Desktop chooses the default flow. |
+| `--guided` | boolean | Prompt through login steps until completion |
+| `--login-id=<value>` | option | Existing login ID to re-login as |
+| `--non-interactive` | boolean | Do not prompt; require --flow, --field, and --cookie values when needed. |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper api get`
+Call a raw Desktop API GET path
+
+```sh
+beeper api get <path>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `path` | yes | API path, for example /v1/info |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper api post`
+Call a raw Desktop API POST path with a JSON body
+
+```sh
+beeper api post <path>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `path` | yes | API path, for example /v1/messages/{chatID}/send |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--body=<value>` | option | JSON request body Default: {} |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper app e2ee recovery-code mark-backed-up`
+Mark the recovery key as saved
+
+```sh
+beeper app e2ee recovery-code mark-backed-up
+```
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper app e2ee recovery-code reset begin`
+Create a new recovery key
+
+```sh
+beeper app e2ee recovery-code reset begin
+```
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--recovery-code=<value>` | option | Existing recovery key, if available |
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper app e2ee recovery-code reset confirm`
+Confirm a newly created recovery key
+
+```sh
+beeper app e2ee recovery-code reset confirm <recoveryCode>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `recoveryCode` | yes | New recovery key returned by reset begin |
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper app e2ee recovery-code verify`
+Unlock encrypted messages with a recovery key
+
+```sh
+beeper app e2ee recovery-code verify <recoveryCode>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `recoveryCode` | yes | Beeper recovery key |
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper app e2ee verification accept`
+Accept a device verification request
+
+```sh
+beeper app e2ee verification accept <txnID>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `txnID` | yes | Verification transaction ID |
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper app e2ee verification cancel`
+Cancel device verification
+
+```sh
+beeper app e2ee verification cancel <txnID>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `txnID` | yes | Verification transaction ID |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--code=<value>` | option | Optional cancellation code |
+| `--reason=<value>` | option | Optional cancellation reason |
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper app e2ee verification qr confirm-scanned`
+Confirm another device scanned this QR code
+
+```sh
+beeper app e2ee verification qr confirm-scanned <txnID>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `txnID` | yes | Verification transaction ID |
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper app e2ee verification qr scan`
+Submit a scanned verification QR payload
+
+```sh
+beeper app e2ee verification qr scan <data>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `data` | yes | QR code payload |
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper app e2ee verification sas confirm`
+Confirm matching emoji verification
+
+```sh
+beeper app e2ee verification sas confirm <txnID>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `txnID` | yes | Verification transaction ID |
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper app e2ee verification sas start`
+Start emoji verification
+
+```sh
+beeper app e2ee verification sas start <txnID>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `txnID` | yes | Verification transaction ID |
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper app e2ee verification start`
+Start device verification
+
+```sh
+beeper app e2ee verification start
+```
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--user-id=<value>` | option | User ID to verify. Defaults to the signed-in user. |
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper app status`
+Show Beeper app login and encrypted messaging state
+
+```sh
+beeper app status
+```
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper archive`
+Archive or unarchive a chat. Set archived=true to move to archive, archived=false to move back to inbox
+
+```sh
+beeper archive <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper assets download`
+Download a Matrix file using its mxc:// or localmxc:// URL to the device running Beeper Desktop and return the local file URL.
+
+```sh
+beeper assets download <url>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `url` | yes | Asset URL |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper assets upload`
+Upload a file to a temporary location using multipart/form-data. Returns an uploadID that can be referenced when sending a message or materializing a draft attachment.
+
+```sh
+beeper assets upload <file>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `file` | yes | The file to upload (max 500 MB). |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--file-name=<value>` | option | Original filename. Defaults to the uploaded file name if omitted |
+| `--mime-type=<value>` | option | MIME type. Auto-detected from magic bytes if omitted |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper auth login`
+Authenticate with local Beeper Desktop
+
+```sh
+beeper auth login
+```
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--accept-terms` | boolean | Accept the Terms of Use and acknowledge the Privacy Policy when creating an account |
+| `--app-login` | boolean | Sign in the local Beeper Desktop app itself instead of requesting a Desktop API token from an already signed-in app |
+| `--client-name=<value>` | option | OAuth client name shown in Beeper Desktop Default: Beeper CLI |
+| `--code=<value>` | option | Email sign-in code |
+| `--email=<value>` | option | Email address to send a sign-in code to |
+| `--no-open` | boolean | Print the authorization URL instead of opening a browser |
+| `--no-save` | boolean | Do not store the returned Desktop API token |
+| `--oauth` | boolean | Use the OAuth2 PKCE Desktop API authorization flow |
+| `--scope=<value>` | option | Space-separated OAuth scopes Default: read write |
+| `--server-url=<value>` | option | Beeper Desktop API server URL |
+| `--username=<value>` | option | Username to create if registration is required |
+
+Global flags: `--json`.
+
+### `beeper auth logout`
+Remove the locally stored Beeper Desktop token
+
+```sh
+beeper auth logout
+```
+
+Global flags: `--json`.
+
+### `beeper auth status`
+Show local auth status and token metadata
+
+```sh
+beeper auth status
+```
+
+Global flags: `--json`.
+
+### `beeper autocomplete`
+Display autocomplete installation instructions.
+
+```sh
+beeper autocomplete [shell]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `shell` | no | Shell type |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `-r, --refresh-cache` | boolean | Refresh cache (ignores displaying instructions) |
+
+### `beeper avatar`
+Set or clear a group chat avatar
+
+```sh
+beeper avatar <chat> [path]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `path` | no | Local avatar image path. Omit with --clear to remove it. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--clear` | boolean | Clear the current avatar |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper chat`
+Retrieve chat details including metadata, participants, and latest message
+
+```sh
+beeper chat <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--max-participants=<value>` | option | Maximum participants to return |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper chat open`
+Focus Beeper Desktop, optionally opening a chat or message
+
+```sh
+beeper chat open [chat] [message]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | no | Chat ID, local chat ID, title, or search text |
+| `message` | no | Message ID |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--attachment=<value>` | option | Draft attachment path |
+| `--draft=<value>` | option | Draft text |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper chats`
+List all chats sorted by last activity (most recent first). Combines all accounts into a single paginated list.
+
+```sh
+beeper chats
+```
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--account=<value>...` | option | Limit to Account ID, network, bridge, or account user |
+| `--ids` | boolean | Print only chat IDs |
+| `--limit=<value>` | option | Maximum chats to print Default: 20 |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper chats search`
+Search chats by title, network, or participant names.
+
+```sh
+beeper chats search <query>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `query` | yes | User-typed search text. Literal word matching (non-semantic). |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--account=<value>...` | option | Limit to Account ID, network, bridge, or account user |
+| `--ids` | boolean | Print only chat IDs |
+| `--inbox=<primary|low-priority|archive>` | option |  |
+| `--include-muted` | boolean | Include muted chats. Use --no-include-muted for a tighter search. |
+| `--last-activity-after=<value>` | option | Only chats with last activity after this ISO timestamp |
+| `--last-activity-before=<value>` | option | Only chats with last activity before this ISO timestamp |
+| `--limit=<value>` | option | Maximum chats to print Default: 20 |
+| `--scope=<titles|participants>` | option |  |
+| `--type=<single|group|any>` | option |  |
+| `--unread` | boolean | Only unread chats |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper clear-draft`
+Clear a chat draft
+
+```sh
+beeper clear-draft <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID, local chat ID, title, or search text |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper commands`
+Print the Beeper CLI command manifest
+
+```sh
+beeper commands
+```
+
+Global flags: `--json`.
+
+### `beeper config get`
+Print CLI configuration
+
+```sh
+beeper config get [key]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `key` | no | Optional config key to print |
+
+Global flags: `--json`.
+
+### `beeper config path`
+Print the CLI config path
+
+```sh
+beeper config path
+```
+
+Global flags: `--json`.
+
+### `beeper config reset`
+Reset CLI configuration
+
+```sh
+beeper config reset
+```
+
+Global flags: `--json`.
+
+### `beeper config set`
+Set a CLI configuration value
+
+```sh
+beeper config set <key> <value>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `key` | yes | Config key to set |
+| `value` | yes | Config value |
+
+Global flags: `--json`.
+
+### `beeper contacts list`
+List merged contacts for a specific account with cursor-based pagination.
+
+```sh
+beeper contacts list <account>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `account` | yes | Account ID, network, bridge, or account user |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--ids` | boolean | Print only contact user IDs |
+| `--limit=<value>` | option | Maximum contacts to print Default: 50 |
+| `--query=<value>` | option | Optional blended contact lookup query |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper contacts search`
+Search contacts on a specific account using merged account contacts, network search, and exact identifier lookup.
+
+```sh
+beeper contacts search <query>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `query` | yes | Contact search query |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--account=<value>...` | option | Account ID, network, bridge, or account user. Omit to search every account. |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper create-chat`
+Create a direct or group chat from participant IDs. Returns the created chat.
+
+```sh
+beeper create-chat
+```
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--account=<value>` | option | Account ID, network, bridge, or account user Required. |
+| `--message=<value>` | option | Optional first message |
+| `--participant=<value>...` | option | Participant user ID Required. |
+| `--title=<value>` | option | Group title |
+| `--type=<single|group>` | option | Chat type Default: single |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper current-user`
+Show the authenticated Desktop API user
+
+```sh
+beeper current-user
+```
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper delete-message`
+Delete a message by final message ID. Pending message IDs are not accepted because messages cannot be deleted while sending.
+
+```sh
+beeper delete-message <chat> <message>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `message` | yes | Message ID. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--for-everyone` | boolean | True to request deletion for everyone when the network supports it; false to delete only for the authenticated user when supported. |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper description`
+Set or clear a group chat description
+
+```sh
+beeper description <chat> [description]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `description` | no | New description. Omit with --clear to remove it. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--clear` | boolean | Clear the current description |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper doctor`
+Verify Desktop API reachability and authentication
+
+```sh
+beeper doctor
+```
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper draft`
+Set a chat draft
+
+```sh
+beeper draft <chat> <text>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID, local chat ID, title, or search text |
+| `text` | yes | Draft text |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--file=<value>` | option | Draft attachment file |
+| `--file-name=<value>` | option | Attachment display filename |
+| `--mime-type=<value>` | option | Attachment MIME type |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper edit`
+Edit the text content of an existing message. Messages with attachments cannot be edited.
+
+```sh
+beeper edit <chat> <message> <text>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `message` | yes | Message ID. |
+| `text` | yes | Draft text. Plain text and Markdown are converted to Matrix HTML with the same rules used by send and edit. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper export`
+Export accounts, chats, messages, Markdown transcripts, and attachments.
+
+```sh
+beeper export
+```
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--account=<value>...` | option | Limit to an account selector. Repeat to include more accounts. |
+| `--chat=<value>...` | option | Limit to a chat selector. Repeat to include more chats. |
+| `--force` | boolean | Re-export chats even if checkpoint state says they are complete. |
+| `--limit-chats=<value>` | option | Maximum chats to export. Intended for testing large exports. |
+| `--limit-messages=<value>` | option | Maximum messages per chat. Intended for testing large exports. |
+| `--max-participants=<value>` | option | Maximum participants to include in each chat.json. Default: 500 |
+| `--no-attachments` | boolean | Skip downloading message attachments. |
+| `-o, --out=<value>` | option | Export directory. Default: beeper-export |
+| `--pick=<value>` | option | Pick the Nth chat when a --chat selector is ambiguous. |
+| `--quiet` | boolean | Suppress progress output. |
+
+Global flags: `--base-url`, `--debug`.
+
+### `beeper focus`
+Focus Beeper Desktop, optionally opening a chat or message
+
+```sh
+beeper focus [chat] [message]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | no | Chat ID, local chat ID, title, or search text |
+| `message` | no | Message ID |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--attachment=<value>` | option | Draft attachment path |
+| `--draft=<value>` | option | Draft text |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper help`
+Display help for beeper.
+
+```sh
+beeper help [command]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `command` | no | Command to show help for. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `-n, --nested-commands` | boolean | Include all nested commands in the output. |
+
+### `beeper inbox`
+Move a chat to the primary inbox
+
+```sh
+beeper inbox <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper llm`
+Print compact CLI help for agents
+
+```sh
+beeper llm
+```
+
+Global flags: `--json`.
+
+### `beeper login`
+Authenticate with local Beeper Desktop
+
+```sh
+beeper login
+```
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--accept-terms` | boolean | Accept the Terms of Use and acknowledge the Privacy Policy when creating an account |
+| `--app-login` | boolean | Sign in the local Beeper Desktop app itself instead of requesting a Desktop API token from an already signed-in app |
+| `--client-name=<value>` | option | OAuth client name shown in Beeper Desktop Default: Beeper CLI |
+| `--code=<value>` | option | Email sign-in code |
+| `--email=<value>` | option | Email address to send a sign-in code to |
+| `--no-open` | boolean | Print the authorization URL instead of opening a browser |
+| `--no-save` | boolean | Do not store the returned Desktop API token |
+| `--oauth` | boolean | Use the OAuth2 PKCE Desktop API authorization flow |
+| `--scope=<value>` | option | Space-separated OAuth scopes Default: read write |
+| `--server-url=<value>` | option | Beeper Desktop API server URL |
+| `--username=<value>` | option | Username to create if registration is required |
+
+Global flags: `--json`.
+
+### `beeper logout`
+Remove the locally stored Beeper Desktop token
+
+```sh
+beeper logout
+```
+
+Global flags: `--json`.
+
+### `beeper low-priority`
+Move a chat to Low Priority
+
+```sh
+beeper low-priority <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper mark-read`
+Mark a chat as read, optionally through a specific message ID.
+
+```sh
+beeper mark-read <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--message=<value>` | option | Message ID. |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper mark-unread`
+Mark a chat as unread, optionally from a specific message ID.
+
+```sh
+beeper mark-unread <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--message=<value>` | option | Message ID. |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper message`
+Retrieve a message by final message ID, pendingMessageID, or Matrix event ID. Chat ID may be a Beeper chat ID or local chat ID.
+
+```sh
+beeper message <chat> <message>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `message` | yes | Message ID. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper message-expiry`
+Set or clear disappearing-message expiry
+
+```sh
+beeper message-expiry <chat> <seconds>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `seconds` | yes | Expiry in seconds, or "off" |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper messages`
+List all messages in a chat with cursor-based pagination. Sorted by timestamp.
+
+```sh
+beeper messages <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--after=<value>` | option | Fetch messages after cursor |
+| `--before=<value>` | option | Fetch messages before cursor |
+| `--ids` | boolean | Print only message IDs |
+| `--limit=<value>` | option | Maximum messages to print Default: 50 |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper messages search`
+Search messages across chats.
+
+```sh
+beeper messages search [query]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `query` | no | User-typed search text. Literal word matching (non-semantic). |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--account=<value>...` | option | Limit to Account ID, network, bridge, or account user |
+| `--chat=<value>...` | option | Limit to Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `--chat-type=<group|single>` | option | Limit to group chats or direct messages |
+| `--date-after=<value>` | option | Only messages after this ISO timestamp |
+| `--date-before=<value>` | option | Only messages before this ISO timestamp |
+| `--exclude-low-priority` | boolean | Exclude low-priority chats. Use --no-exclude-low-priority to include all. |
+| `--ids` | boolean | Print only message IDs |
+| `--include-muted` | boolean | Include muted chats. Use --no-include-muted for a tighter search. |
+| `--limit=<value>` | option | Maximum messages to print Default: 50 |
+| `--media=<any|video|image|link|file>...` | option | Filter by media type. Repeat for more types. |
+| `--sender=<value>` | option | me, others, or a user ID |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper mute`
+Mute a chat
+
+```sh
+beeper mute <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID, local chat ID, title, or search text |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper notify-anyway`
+Force a delivery notification when supported by the underlying network. Currently intended for iMessage on macOS; unsupported networks return an error.
+
+```sh
+beeper notify-anyway <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper pin`
+Pin a chat
+
+```sh
+beeper pin <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper react`
+Add a reaction to an existing message.
+
+```sh
+beeper react <chat> <message> <reaction>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `message` | yes | Message ID. |
+| `reaction` | yes | Reaction key to add (emoji, shortcode, or custom emoji key) |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+| `--transaction=<value>` | option | Optional transaction ID |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper read`
+Mark a chat as read, optionally through a specific message ID.
+
+```sh
+beeper read <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--message=<value>` | option | Message ID. |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper remind`
+Set a reminder for a chat at a specific time
+
+```sh
+beeper remind <chat> <when>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `when` | yes | Timestamp when the reminder should trigger. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--dismiss-on-message` | boolean | Cancel if someone messages in the chat |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper reply`
+Send a text message to a specific chat. Supports replying to existing messages. Returns a pending message ID.
+
+```sh
+beeper reply <chat> <message> <text>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `message` | yes | Provide a message ID to send this as a reply to an existing message |
+| `text` | yes | Draft text. Plain text and Markdown are converted to Matrix HTML with the same rules used by send and edit. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--file=<value>` | option | The file to upload (max 500 MB). |
+| `--file-name=<value>` | option | Original filename. Defaults to the uploaded file name if omitted |
+| `--mime-type=<value>` | option | MIME type. Auto-detected from magic bytes if omitted |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+| `--wait` | boolean | Wait for the pending message to resolve |
+| `--wait-interval=<value>` | option | Milliseconds between message status checks Default: 750 |
+| `--wait-timeout=<value>` | option | Milliseconds to wait for message resolution Default: 30000 |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper reply-file`
+Send a text message to a specific chat. Supports replying to existing messages. Returns a pending message ID.
+
+```sh
+beeper reply-file <chat> <message> <file> [text]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `message` | yes | Provide a message ID to send this as a reply to an existing message |
+| `file` | yes | The file to upload (max 500 MB). |
+| `text` | no | Draft text. Plain text and Markdown are converted to Matrix HTML with the same rules used by send and edit. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--file-name=<value>` | option | Original filename. Defaults to the uploaded file name if omitted |
+| `--mime-type=<value>` | option | MIME type. Auto-detected from magic bytes if omitted |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+| `--wait` | boolean | Wait for the pending message to resolve |
+| `--wait-interval=<value>` | option | Milliseconds between message status checks Default: 750 |
+| `--wait-timeout=<value>` | option | Milliseconds to wait for message resolution Default: 30000 |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper rpc`
+Run newline-delimited JSON command RPC
+
+```sh
+beeper rpc
+```
+
+### `beeper search`
+Search chats and messages
+
+```sh
+beeper search <query>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `query` | yes | Literal search query |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper send`
+Send a text message to a specific chat. Supports replying to existing messages. Returns a pending message ID.
+
+```sh
+beeper send <chat> <text>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `text` | yes | Draft text. Plain text and Markdown are converted to Matrix HTML with the same rules used by send and edit. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--file=<value>` | option | The file to upload (max 500 MB). |
+| `--file-name=<value>` | option | Original filename. Defaults to the uploaded file name if omitted |
+| `--mime-type=<value>` | option | MIME type. Auto-detected from magic bytes if omitted |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+| `--reply-to=<value>` | option | Provide a message ID to send this as a reply to an existing message |
+| `--wait` | boolean | Wait for the pending message to resolve |
+| `--wait-interval=<value>` | option | Milliseconds between message status checks Default: 750 |
+| `--wait-timeout=<value>` | option | Milliseconds to wait for message resolution Default: 30000 |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper send-file`
+Send a text message to a specific chat. Supports replying to existing messages. Returns a pending message ID.
+
+```sh
+beeper send-file <chat> <file> [text]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `file` | yes | The file to upload (max 500 MB). |
+| `text` | no | Draft text. Plain text and Markdown are converted to Matrix HTML with the same rules used by send and edit. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--file-name=<value>` | option | Original filename. Defaults to the uploaded file name if omitted |
+| `--mime-type=<value>` | option | MIME type. Auto-detected from magic bytes if omitted |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+| `--reply-to=<value>` | option | Provide a message ID to send this as a reply to an existing message |
+| `--wait` | boolean | Wait for the pending message to resolve |
+| `--wait-interval=<value>` | option | Milliseconds between message status checks Default: 750 |
+| `--wait-timeout=<value>` | option | Milliseconds to wait for message resolution Default: 30000 |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper shell`
+Run an interactive Beeper CLI shell
+
+```sh
+beeper shell
+```
+
+### `beeper start-chat`
+Resolve a user/contact and open a direct chat. Reuses and returns an existing direct chat when one is found. Available in Beeper Desktop v4.2.808+.
+
+```sh
+beeper start-chat [query]
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `query` | no | Phone, email, username, user ID, or name |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--account=<value>...` | option | Account ID, network, bridge, or account user. Omit to try every account. |
+| `--allow-invite` | boolean | Allow invite-based DM creation when required |
+| `--email=<value>` | option | Email address |
+| `--id=<value>` | option | Known user ID |
+| `--message=<value>` | option | Optional first message |
+| `--name=<value>` | option | Display name hint |
+| `--phone=<value>` | option | Phone number |
+| `--username=<value>` | option | Username |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper status`
+Check Beeper Desktop API status
+
+```sh
+beeper status
+```
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper tail`
+Stream Desktop API WebSocket events
 
 ```sh
-brew install beeper/tap/beeper-desktop-cli
+beeper tail
 ```
 
-### Installing with Go
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `-c, --chat=<value>...` | option | Chat ID to subscribe to. Defaults to all chats. |
+
+Global flags: `--base-url`, `--json`.
+
+### `beeper thread`
+Retrieve chat details including metadata, participants, and latest message
+
+```sh
+beeper thread <chat>
+```
+
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
 
-To test or install the CLI locally, you need [Go](https://go.dev/doc/install) version 1.22 or later installed.
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--max-participants=<value>` | option | Maximum participants to return |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper threads`
+List all chats sorted by last activity (most recent first). Combines all accounts into a single paginated list.
 
 ```sh
-go install 'github.com/beeper/desktop-api-cli/cmd/beeper-desktop-cli@latest'
+beeper threads
 ```
 
-Once you have run `go install`, the binary is placed in your Go bin directory:
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--account=<value>...` | option | Limit to Account ID, network, bridge, or account user |
+| `--ids` | boolean | Print only chat IDs |
+| `--limit=<value>` | option | Maximum chats to print Default: 20 |
 
-- **Default location**: `$HOME/go/bin` (or `$GOPATH/bin` if GOPATH is set)
-- **Check your path**: Run `go env GOPATH` to see the base directory
+Global flags: `--base-url`, `--debug`, `--json`.
 
-If commands aren't found after installation, add the Go bin directory to your PATH:
+### `beeper title`
+Set a custom chat title
 
 ```sh
-# Add to your shell profile (.zshrc, .bashrc, etc.)
-export PATH="$PATH:$(go env GOPATH)/bin"
+beeper title <chat> <title>
 ```
 
-<!-- x-release-please-end -->
+Arguments:
 
-### Running Locally
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `title` | yes | New chat title |
 
-After cloning the git repository for this project, you can use the
-`scripts/run` script to run the tool locally:
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper unarchive`
+Archive or unarchive a chat. Set archived=true to move to archive, archived=false to move back to inbox
 
 ```sh
-./scripts/run args...
+beeper unarchive <chat>
 ```
 
-## Usage
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
 
-The CLI follows a resource-based command structure:
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper unmute`
+Unmute a chat
 
 ```sh
-beeper-desktop-cli [resource] <command> [flags...]
+beeper unmute <chat>
 ```
 
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID, local chat ID, title, or search text |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper unpin`
+Unpin a chat
+
 ```sh
-beeper-desktop-cli chats search \
-  --include-muted \
-  --limit 3 \
-  --type single
+beeper unpin <chat>
 ```
 
-For details about specific commands, use the `--help` flag.
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper unreact`
+Remove the reaction added by the authenticated user from an existing message.
+
+```sh
+beeper unreact <chat> <message> <reaction>
+```
 
-### Environment variables
+Arguments:
 
-| Environment variable  | Description                                                                                           | Required |
-| --------------------- | ----------------------------------------------------------------------------------------------------- | -------- |
-| `BEEPER_ACCESS_TOKEN` | Bearer access token obtained via OAuth2 PKCE flow or created in-app. Required for all API operations. | yes      |
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+| `message` | yes | Message ID. |
+| `reaction` | yes | Reaction key to add (emoji, shortcode, or custom emoji key) |
 
-### Global flags
+Flags:
 
-- `--access-token` - Bearer access token obtained via OAuth2 PKCE flow or created in-app. Required for all API operations. (can also be set with `BEEPER_ACCESS_TOKEN` env var)
-- `--help` - Show command line usage
-- `--debug` - Enable debug logging (includes HTTP request/response details)
-- `--version`, `-v` - Show the CLI version
-- `--base-url` - Use a custom API backend URL
-- `--format` - Change the output format (`auto`, `explore`, `json`, `jsonl`, `pretty`, `raw`, `yaml`)
-- `--format-error` - Change the output format for errors (`auto`, `explore`, `json`, `jsonl`, `pretty`, `raw`, `yaml`)
-- `--transform` - Transform the data output using [GJSON syntax](https://github.com/tidwall/gjson/blob/master/SYNTAX.md)
-- `--transform-error` - Transform the error output using [GJSON syntax](https://github.com/tidwall/gjson/blob/master/SYNTAX.md)
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
 
-### Passing files as arguments
+Global flags: `--base-url`, `--debug`, `--json`.
 
-To pass files to your API, you can use the `@myfile.ext` syntax:
+### `beeper unread`
+Mark a chat as unread, optionally from a specific message ID.
 
-```bash
-beeper-desktop-cli <command> --arg @abe.jpg
+```sh
+beeper unread <chat>
 ```
 
-Files can also be passed inside JSON or YAML blobs:
+Arguments:
+
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
 
-```bash
-beeper-desktop-cli <command> --arg '{image: "@abe.jpg"}'
-# Equivalent:
-beeper-desktop-cli <command> <<YAML
-arg:
-  image: "@abe.jpg"
-YAML
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--message=<value>` | option | Message ID. |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper unremind`
+Clear an existing reminder from a chat
+
+```sh
+beeper unremind <chat>
 ```
 
-If you need to pass a string literal that begins with an `@` sign, you can
-escape the `@` sign to avoid accidentally passing a file.
+Arguments:
 
-```bash
-beeper-desktop-cli <command> --username '\@abe'
+| Name | Required | Description |
+| --- | --- | --- |
+| `chat` | yes | Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available. Also accepts exact chat titles or search text. |
+
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `--pick=<value>` | option | Pick the Nth chat when the input is ambiguous |
+
+Global flags: `--base-url`, `--debug`, `--json`.
+
+### `beeper watch`
+Stream Desktop API WebSocket events
+
+```sh
+beeper watch
 ```
 
-#### Explicit encoding
+Flags:
+
+| Flag | Type | Description |
+| --- | --- | --- |
+| `-c, --chat=<value>...` | option | Chat ID to subscribe to. Defaults to all chats. |
+
+Global flags: `--base-url`, `--json`.
 
-For JSON endpoints, the CLI tool does filetype sniffing to determine whether the
-file contents should be sent as a string literal (for plain text files) or as a
-base64-encoded string literal (for binary files). If you need to explicitly send
-the file as either plain text or base64-encoded data, you can use
-`@file://myfile.txt` (for string encoding) or `@data://myfile.dat` (for
-base64-encoding). Note that absolute paths will begin with `@file://` or
-`@data://`, followed by a third `/` (for example, `@file:///tmp/file.txt`).
+### `beeper whoami`
+Show the authenticated Desktop API user
 
-```bash
-beeper-desktop-cli <command> --arg @data://file.txt
+```sh
+beeper whoami
 ```
+
+Global flags: `--base-url`, `--json`.
+
+## Publishing
+
+Beeper CLI releases are built as Homebrew archives and uploaded to GitHub
+Releases. Push a `v*` tag to run `.github/workflows/publish-release.yml`.
+
+The release workflow:
+
+- runs the TypeScript test suite
+- builds a Homebrew archive containing the compiled CLI and production dependencies
+- uploads the archive to the GitHub release
+- updates `beeper/homebrew-tap` with the pinned archive SHA
+
+Required repository secrets:
+
+- `HOMEBREW_TAP_GITHUB_TOKEN`
diff --git a/bin/check-release-environment b/bin/check-release-environment
index 1e951e9..0a2b720 100644
--- a/bin/check-release-environment
+++ b/bin/check-release-environment
@@ -1,7 +1,20 @@
 #!/usr/bin/env bash
+set -euo pipefail
 
 errors=()
 
+for path in package.json package-lock.json scripts/build-homebrew-archive.mjs scripts/publish-homebrew-formula.mjs .github/workflows/publish-release.yml; do
+  if [[ ! -f "${path}" ]]; then
+    errors+=("Missing required release file: ${path}")
+  fi
+done
+
+for command in node npm git gh tar; do
+  if ! command -v "${command}" >/dev/null 2>&1; then
+    errors+=("Missing required release command: ${command}")
+  fi
+done
+
 lenErrors=${#errors[@]}
 
 if [[ lenErrors -gt 0 ]]; then
diff --git a/bin/dev.js b/bin/dev.js
new file mode 100755
index 0000000..e91fe4c
--- /dev/null
+++ b/bin/dev.js
@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { execute } from '@oclif/core'
+
+await execute({ development: true, dir: import.meta.url })
diff --git a/bin/run.js b/bin/run.js
new file mode 100755
index 0000000..3492285
--- /dev/null
+++ b/bin/run.js
@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { execute } from '@oclif/core'
+
+await execute({ dir: import.meta.url })
diff --git a/bun.lock b/bun.lock
new file mode 100644
index 0000000..b72ead1
--- /dev/null
+++ b/bun.lock
@@ -0,0 +1,294 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 0,
+  "workspaces": {
+    "": {
+      "name": "@beeper/desktop-api-cli",
+      "dependencies": {
+        "@beeper/desktop-api": "^5.0.0",
+        "@oclif/core": "^4.11.2",
+        "@oclif/plugin-autocomplete": "^3.2.49",
+        "@oclif/plugin-help": "^6.2.48",
+        "@oclif/plugin-not-found": "^3.2.85",
+        "@opentui/core": "^0.2.9",
+        "@opentui/react": "^0.2.9",
+      },
+      "devDependencies": {
+        "@types/node": "^25.7.0",
+        "tsx": "^4.21.0",
+        "typescript": "^6.0.3",
+      },
+    },
+  },
+  "packages": {
+    "@beeper/desktop-api": ["@beeper/desktop-api@5.0.0", "", {}, "sha512-f9GhxQw6E0VMiVJGcdkUPNc6qCypaQlgMgxG6yU2lLy9gzx8xEObYnJbuhmT+HBg2SaQzNB33fC5ZT4OL3GnQw=="],
+
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.7", "", { "os": "aix", "cpu": "ppc64" }, "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.27.7", "", { "os": "android", "cpu": "arm" }, "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.27.7", "", { "os": "android", "cpu": "arm64" }, "sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.27.7", "", { "os": "android", "cpu": "x64" }, "sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.27.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.27.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.27.7", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.27.7", "", { "os": "freebsd", "cpu": "x64" }, "sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.27.7", "", { "os": "linux", "cpu": "arm" }, "sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.27.7", "", { "os": "linux", "cpu": "arm64" }, "sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.27.7", "", { "os": "linux", "cpu": "ia32" }, "sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.27.7", "", { "os": "linux", "cpu": "ppc64" }, "sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.27.7", "", { "os": "linux", "cpu": "none" }, "sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.27.7", "", { "os": "linux", "cpu": "s390x" }, "sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.27.7", "", { "os": "linux", "cpu": "x64" }, "sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA=="],
+
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.27.7", "", { "os": "none", "cpu": "arm64" }, "sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.27.7", "", { "os": "none", "cpu": "x64" }, "sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw=="],
+
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.27.7", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.27.7", "", { "os": "openbsd", "cpu": "x64" }, "sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg=="],
+
+    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.27.7", "", { "os": "none", "cpu": "arm64" }, "sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.27.7", "", { "os": "sunos", "cpu": "x64" }, "sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.27.7", "", { "os": "win32", "cpu": "arm64" }, "sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.27.7", "", { "os": "win32", "cpu": "ia32" }, "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.27.7", "", { "os": "win32", "cpu": "x64" }, "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg=="],
+
+    "@inquirer/ansi": ["@inquirer/ansi@1.0.2", "", {}, "sha512-S8qNSZiYzFd0wAcyG5AXCvUHC5Sr7xpZ9wZ2py9XR88jUz8wooStVx5M6dRzczbBWjic9NP7+rY0Xi7qqK/aMQ=="],
+
+    "@inquirer/checkbox": ["@inquirer/checkbox@4.3.2", "", { "dependencies": { "@inquirer/ansi": "^1.0.2", "@inquirer/core": "^10.3.2", "@inquirer/figures": "^1.0.15", "@inquirer/type": "^3.0.10", "yoctocolors-cjs": "^2.1.3" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-VXukHf0RR1doGe6Sm4F0Em7SWYLTHSsbGfJdS9Ja2bX5/D5uwVOEjr07cncLROdBvmnvCATYEWlHqYmXv2IlQA=="],
+
+    "@inquirer/confirm": ["@inquirer/confirm@5.1.21", "", { "dependencies": { "@inquirer/core": "^10.3.2", "@inquirer/type": "^3.0.10" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-KR8edRkIsUayMXV+o3Gv+q4jlhENF9nMYUZs9PA2HzrXeHI8M5uDag70U7RJn9yyiMZSbtF5/UexBtAVtZGSbQ=="],
+
+    "@inquirer/core": ["@inquirer/core@10.3.2", "", { "dependencies": { "@inquirer/ansi": "^1.0.2", "@inquirer/figures": "^1.0.15", "@inquirer/type": "^3.0.10", "cli-width": "^4.1.0", "mute-stream": "^2.0.0", "signal-exit": "^4.1.0", "wrap-ansi": "^6.2.0", "yoctocolors-cjs": "^2.1.3" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-43RTuEbfP8MbKzedNqBrlhhNKVwoK//vUFNW3Q3vZ88BLcrs4kYpGg+B2mm5p2K/HfygoCxuKwJJiv8PbGmE0A=="],
+
+    "@inquirer/editor": ["@inquirer/editor@4.2.23", "", { "dependencies": { "@inquirer/core": "^10.3.2", "@inquirer/external-editor": "^1.0.3", "@inquirer/type": "^3.0.10" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-aLSROkEwirotxZ1pBaP8tugXRFCxW94gwrQLxXfrZsKkfjOYC1aRvAZuhpJOb5cu4IBTJdsCigUlf2iCOu4ZDQ=="],
+
+    "@inquirer/expand": ["@inquirer/expand@4.0.23", "", { "dependencies": { "@inquirer/core": "^10.3.2", "@inquirer/type": "^3.0.10", "yoctocolors-cjs": "^2.1.3" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-nRzdOyFYnpeYTTR2qFwEVmIWypzdAx/sIkCMeTNTcflFOovfqUk+HcFhQQVBftAh9gmGrpFj6QcGEqrDMDOiew=="],
+
+    "@inquirer/external-editor": ["@inquirer/external-editor@1.0.3", "", { "dependencies": { "chardet": "^2.1.1", "iconv-lite": "^0.7.0" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA=="],
+
+    "@inquirer/figures": ["@inquirer/figures@1.0.15", "", {}, "sha512-t2IEY+unGHOzAaVM5Xx6DEWKeXlDDcNPeDyUpsRc6CUhBfU3VQOEl+Vssh7VNp1dR8MdUJBWhuObjXCsVpjN5g=="],
+
+    "@inquirer/input": ["@inquirer/input@4.3.1", "", { "dependencies": { "@inquirer/core": "^10.3.2", "@inquirer/type": "^3.0.10" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-kN0pAM4yPrLjJ1XJBjDxyfDduXOuQHrBB8aLDMueuwUGn+vNpF7Gq7TvyVxx8u4SHlFFj4trmj+a2cbpG4Jn1g=="],
+
+    "@inquirer/number": ["@inquirer/number@3.0.23", "", { "dependencies": { "@inquirer/core": "^10.3.2", "@inquirer/type": "^3.0.10" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-5Smv0OK7K0KUzUfYUXDXQc9jrf8OHo4ktlEayFlelCjwMXz0299Y8OrI+lj7i4gCBY15UObk76q0QtxjzFcFcg=="],
+
+    "@inquirer/password": ["@inquirer/password@4.0.23", "", { "dependencies": { "@inquirer/ansi": "^1.0.2", "@inquirer/core": "^10.3.2", "@inquirer/type": "^3.0.10" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-zREJHjhT5vJBMZX/IUbyI9zVtVfOLiTO66MrF/3GFZYZ7T4YILW5MSkEYHceSii/KtRk+4i3RE7E1CUXA2jHcA=="],
+
+    "@inquirer/prompts": ["@inquirer/prompts@7.10.1", "", { "dependencies": { "@inquirer/checkbox": "^4.3.2", "@inquirer/confirm": "^5.1.21", "@inquirer/editor": "^4.2.23", "@inquirer/expand": "^4.0.23", "@inquirer/input": "^4.3.1", "@inquirer/number": "^3.0.23", "@inquirer/password": "^4.0.23", "@inquirer/rawlist": "^4.1.11", "@inquirer/search": "^3.2.2", "@inquirer/select": "^4.4.2" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-Dx/y9bCQcXLI5ooQ5KyvA4FTgeo2jYj/7plWfV5Ak5wDPKQZgudKez2ixyfz7tKXzcJciTxqLeK7R9HItwiByg=="],
+
+    "@inquirer/rawlist": ["@inquirer/rawlist@4.1.11", "", { "dependencies": { "@inquirer/core": "^10.3.2", "@inquirer/type": "^3.0.10", "yoctocolors-cjs": "^2.1.3" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-+LLQB8XGr3I5LZN/GuAHo+GpDJegQwuPARLChlMICNdwW7OwV2izlCSCxN6cqpL0sMXmbKbFcItJgdQq5EBXTw=="],
+
+    "@inquirer/search": ["@inquirer/search@3.2.2", "", { "dependencies": { "@inquirer/core": "^10.3.2", "@inquirer/figures": "^1.0.15", "@inquirer/type": "^3.0.10", "yoctocolors-cjs": "^2.1.3" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-p2bvRfENXCZdWF/U2BXvnSI9h+tuA8iNqtUKb9UWbmLYCRQxd8WkvwWvYn+3NgYaNwdUkHytJMGG4MMLucI1kA=="],
+
+    "@inquirer/select": ["@inquirer/select@4.4.2", "", { "dependencies": { "@inquirer/ansi": "^1.0.2", "@inquirer/core": "^10.3.2", "@inquirer/figures": "^1.0.15", "@inquirer/type": "^3.0.10", "yoctocolors-cjs": "^2.1.3" }, "peerDependencies": { "@types/node": ">=18" } }, "sha512-l4xMuJo55MAe+N7Qr4rX90vypFwCajSakx59qe/tMaC1aEHWLyw68wF4o0A4SLAY4E0nd+Vt+EyskeDIqu1M6w=="],
+
+    "@inquirer/type": ["@inquirer/type@3.0.10", "", { "peerDependencies": { "@types/node": ">=18" } }, "sha512-BvziSRxfz5Ov8ch0z/n3oijRSEcEsHnhggm4xFZe93DHcUCTlutlq9Ox4SVENAfcRD22UQq7T/atg9Wr3k09eA=="],
+
+    "@oclif/core": ["@oclif/core@4.11.2", "", { "dependencies": { "ansi-escapes": "^4.3.2", "ansis": "^3.17.0", "clean-stack": "^3.0.1", "cli-spinners": "^2.9.2", "debug": "^4.4.3", "ejs": "^3.1.10", "get-package-type": "^0.1.0", "indent-string": "^4.0.0", "is-wsl": "^2.2.0", "lilconfig": "^3.1.3", "minimatch": "^10.2.5", "semver": "^7.8.0", "string-width": "^4.2.3", "supports-color": "^8", "tinyglobby": "^0.2.14", "widest-line": "^3.1.0", "wordwrap": "^1.0.0", "wrap-ansi": "^7.0.0" } }, "sha512-LWDalCgy+hYyAkLa9sMIXMXk6ws5RzQhVnkmfXtVIIyEEYigbXQ/9/x+s76p53MiXxNc6SJB7lfwkPF+SdzfMQ=="],
+
+    "@oclif/plugin-autocomplete": ["@oclif/plugin-autocomplete@3.2.49", "", { "dependencies": { "@oclif/core": "^4", "ansis": "^3.16.0", "debug": "^4.4.1", "ejs": "^3.1.10" } }, "sha512-+rrAZ468bW/B9uVrn6sEnFYepy3M1N/BWht8mHzhFIFCIduPSoE+8MweROxZLOGBZrXGWt0iavuPQmy0eaXRfQ=="],
+
+    "@oclif/plugin-help": ["@oclif/plugin-help@6.2.48", "", { "dependencies": { "@oclif/core": "^4" } }, "sha512-nvGLBtUZUWrHfoAEDRsRZUHKVwptyZ6F+MErdVRLQBo3dja0GCZH8DE33dA7mBux2KOmbxGqop15gyud9HZYhQ=="],
+
+    "@oclif/plugin-not-found": ["@oclif/plugin-not-found@3.2.85", "", { "dependencies": { "@inquirer/prompts": "^7.10.1", "@oclif/core": "^4.11.2", "ansis": "^3.17.0", "fast-levenshtein": "^3.0.0" } }, "sha512-Si18rRKWknlvQ5anmFbQz9oKBae5/l/Npreuf05xdoNWfOV1J97Z7cpzqBlHbldmxCIiDRgmDKuCBBi4XN6ACA=="],
+
+    "@opentui/core": ["@opentui/core@0.2.9", "", { "dependencies": { "bun-ffi-structs": "0.2.2", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2", "yoga-layout": "3.2.1" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.2.9", "@opentui/core-darwin-x64": "0.2.9", "@opentui/core-linux-arm64": "0.2.9", "@opentui/core-linux-x64": "0.2.9", "@opentui/core-win32-arm64": "0.2.9", "@opentui/core-win32-x64": "0.2.9" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-Kmeqi+yiDau+P45xDeX08GS50FK917qVwuPTN7HGxsQ9Byt7Iifq/6OMiSnFULBzoZtECdKLgQF1XwLsNm1wig=="],
+
+    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.2.9", "", { "os": "darwin", "cpu": "arm64" }, "sha512-D2ne8Xgyrg71L/9lF7vPh30Sxz6+3yAqpT0m87WiI+040J7sQEyK3YM/7w5JKuVemQ4H54HSPjofrUHjfibjoQ=="],
+
+    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.2.9", "", { "os": "darwin", "cpu": "x64" }, "sha512-Ymbbt/wN/vgB8g+kbHospJclVKHq6cdgfEYg9qgsSHp2vqMFBqlQQ692MS3BcZfX9jrKROK7NvC6Hj37X5K/7Q=="],
+
+    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.2.9", "", { "os": "linux", "cpu": "arm64" }, "sha512-0RIrVe4+42oELHtSJBaaYhngUeMKwSeqfdtKeSwEFwCzrqrNXxCpXQdOo8QvjOKGgng4Smn6O6KM8sgCj4SSPQ=="],
+
+    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.2.9", "", { "os": "linux", "cpu": "x64" }, "sha512-fjCZP1IOLWm68FYl2PRzFg1vfu226FPfiJsdNtLbhaYF2uEZOB/v1BQph21OKnB7GC7X8GQatvhM5sS3DQ2MSQ=="],
+
+    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.2.9", "", { "os": "win32", "cpu": "arm64" }, "sha512-u8SP3u2QEJqcGIULYZ7Lkht9ss7wcN4/LnMuqt9rPOiCduFn/VW4r8lQCftZ6DRSqyoP9mJ1xLzOSFl98UYyEw=="],
+
+    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.2.9", "", { "os": "win32", "cpu": "x64" }, "sha512-un7iSy9XHLwa6ouVpUj3eEGnXfPG50OMUJ2Dt30Jvn2vhNwIU2VO4RGx06l5OUD6GGVpHb0RqmG/384oo9i+HA=="],
+
+    "@opentui/react": ["@opentui/react@0.2.9", "", { "dependencies": { "@opentui/core": "0.2.9", "react-reconciler": "^0.33.0" }, "peerDependencies": { "react": ">=19.2.0", "react-devtools-core": "^7.0.1", "ws": "^8.18.0" } }, "sha512-ND7imCKHOGutSgevbzJJ+sUwp4fyPY64byibRbC9v/daOW8GudSYL2la5webxCn2PrNfR1bI7mfGMNZ9oW2uow=="],
+
+    "@types/node": ["@types/node@25.7.0", "", { "dependencies": { "undici-types": "~7.21.0" } }, "sha512-z+pdZyxE+RTQE9AcboAZCb4otwcrvgHD+GlBpPgn0emDVt0ohrTMhAwlr2Wd9nZ+nihhYFxO2pThz3C5qSu2Eg=="],
+
+    "ansi-escapes": ["ansi-escapes@4.3.2", "", { "dependencies": { "type-fest": "^0.21.3" } }, "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ=="],
+
+    "ansi-regex": ["ansi-regex@6.2.2", "", {}, "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg=="],
+
+    "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
+
+    "ansis": ["ansis@3.17.0", "", {}, "sha512-0qWUglt9JEqLFr3w1I1pbrChn1grhaiAR2ocX1PP/flRmxgtwTzPFFFnfIlD6aMOLQZgSuCRlidD70lvx8yhzg=="],
+
+    "async": ["async@3.2.6", "", {}, "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA=="],
+
+    "balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
+
+    "brace-expansion": ["brace-expansion@5.0.6", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g=="],
+
+    "bun-ffi-structs": ["bun-ffi-structs@0.2.2", "", { "peerDependencies": { "typescript": "^5" } }, "sha512-N/ZWtyN0piZlrXQT7TO0V+q952orYqkfhXRXM1Hcbb+R3QSiBH4vLnib187Mrs1H7pWIYECAmPeapGYDOMCl+w=="],
+
+    "chardet": ["chardet@2.1.1", "", {}, "sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ=="],
+
+    "clean-stack": ["clean-stack@3.0.1", "", { "dependencies": { "escape-string-regexp": "4.0.0" } }, "sha512-lR9wNiMRcVQjSB3a7xXGLuz4cr4wJuuXlaAEbRutGowQTmlp7R72/DOgN21e8jdwblMWl9UOJMJXarX94pzKdg=="],
+
+    "cli-spinners": ["cli-spinners@2.9.2", "", {}, "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg=="],
+
+    "cli-width": ["cli-width@4.1.0", "", {}, "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ=="],
+
+    "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
+
+    "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "diff": ["diff@9.0.0", "", {}, "sha512-svtcdpS8CgJyqAjEQIXdb3OjhFVVYjzGAPO8WGCmRbrml64SPw/jJD4GoE98aR7r25A0XcgrK3F02yw9R/vhQw=="],
+
+    "ejs": ["ejs@3.1.10", "", { "dependencies": { "jake": "^10.8.5" }, "bin": "bin/cli.js" }, "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA=="],
+
+    "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "esbuild": ["esbuild@0.27.7", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.27.7", "@esbuild/android-arm": "0.27.7", "@esbuild/android-arm64": "0.27.7", "@esbuild/android-x64": "0.27.7", "@esbuild/darwin-arm64": "0.27.7", "@esbuild/darwin-x64": "0.27.7", "@esbuild/freebsd-arm64": "0.27.7", "@esbuild/freebsd-x64": "0.27.7", "@esbuild/linux-arm": "0.27.7", "@esbuild/linux-arm64": "0.27.7", "@esbuild/linux-ia32": "0.27.7", "@esbuild/linux-loong64": "0.27.7", "@esbuild/linux-mips64el": "0.27.7", "@esbuild/linux-ppc64": "0.27.7", "@esbuild/linux-riscv64": "0.27.7", "@esbuild/linux-s390x": "0.27.7", "@esbuild/linux-x64": "0.27.7", "@esbuild/netbsd-arm64": "0.27.7", "@esbuild/netbsd-x64": "0.27.7", "@esbuild/openbsd-arm64": "0.27.7", "@esbuild/openbsd-x64": "0.27.7", "@esbuild/openharmony-arm64": "0.27.7", "@esbuild/sunos-x64": "0.27.7", "@esbuild/win32-arm64": "0.27.7", "@esbuild/win32-ia32": "0.27.7", "@esbuild/win32-x64": "0.27.7" }, "bin": "bin/esbuild" }, "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w=="],
+
+    "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="],
+
+    "fast-levenshtein": ["fast-levenshtein@3.0.0", "", { "dependencies": { "fastest-levenshtein": "^1.0.7" } }, "sha512-hKKNajm46uNmTlhHSyZkmToAc56uZJwYq7yrciZjqOxnlfQwERDQJmHPUp7m1m9wx8vgOe8IaCKZ5Kv2k1DdCQ=="],
+
+    "fastest-levenshtein": ["fastest-levenshtein@1.0.16", "", {}, "sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg=="],
+
+    "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" } }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
+
+    "filelist": ["filelist@1.0.6", "", { "dependencies": { "minimatch": "^5.0.1" } }, "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA=="],
+
+    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
+    "get-east-asian-width": ["get-east-asian-width@1.6.0", "", {}, "sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA=="],
+
+    "get-package-type": ["get-package-type@0.1.0", "", {}, "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q=="],
+
+    "get-tsconfig": ["get-tsconfig@4.14.0", "", { "dependencies": { "resolve-pkg-maps": "^1.0.0" } }, "sha512-yTb+8DXzDREzgvYmh6s9vHsSVCHeC0G3PI5bEXNBHtmshPnO+S5O7qgLEOn0I5QvMy6kpZN8K1NKGyilLb93wA=="],
+
+    "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
+
+    "iconv-lite": ["iconv-lite@0.7.2", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw=="],
+
+    "indent-string": ["indent-string@4.0.0", "", {}, "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg=="],
+
+    "is-docker": ["is-docker@2.2.1", "", { "bin": "cli.js" }, "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ=="],
+
+    "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
+
+    "is-wsl": ["is-wsl@2.2.0", "", { "dependencies": { "is-docker": "^2.0.0" } }, "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww=="],
+
+    "jake": ["jake@10.9.4", "", { "dependencies": { "async": "^3.2.6", "filelist": "^1.0.4", "picocolors": "^1.1.1" }, "bin": "bin/cli.js" }, "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA=="],
+
+    "lilconfig": ["lilconfig@3.1.3", "", {}, "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw=="],
+
+    "marked": ["marked@17.0.1", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-boeBdiS0ghpWcSwoNm/jJBwdpFaMnZWRzjA6SkUMYb40SVaN1x7mmfGKp0jvexGcx+7y2La5zRZsYFZI6Qpypg=="],
+
+    "minimatch": ["minimatch@10.2.5", "", { "dependencies": { "brace-expansion": "^5.0.5" } }, "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "mute-stream": ["mute-stream@2.0.0", "", {}, "sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA=="],
+
+    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
+    "picomatch": ["picomatch@4.0.4", "", {}, "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A=="],
+
+    "react": ["react@19.2.6", "", {}, "sha512-sfWGGfavi0xr8Pg0sVsyHMAOziVYKgPLNrS7ig+ivMNb3wbCBw3KxtflsGBAwD3gYQlE/AEZsTLgToRrSCjb0Q=="],
+
+    "react-devtools-core": ["react-devtools-core@7.0.1", "", { "dependencies": { "shell-quote": "^1.6.1", "ws": "^7" } }, "sha512-C3yNvRHaizlpiASzy7b9vbnBGLrhvdhl1CbdU6EnZgxPNbai60szdLtl+VL76UNOt5bOoVTOz5rNWZxgGt+Gsw=="],
+
+    "react-reconciler": ["react-reconciler@0.33.0", "", { "dependencies": { "scheduler": "^0.27.0" }, "peerDependencies": { "react": "^19.2.0" } }, "sha512-KetWRytFv1epdpJc3J4G75I4WrplZE5jOL7Yq0p34+OVOKF4Se7WrdIdVC45XsSSmUTlht2FM/fM1FZb1mfQeA=="],
+
+    "resolve-pkg-maps": ["resolve-pkg-maps@1.0.0", "", {}, "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw=="],
+
+    "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="],
+
+    "scheduler": ["scheduler@0.27.0", "", {}, "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q=="],
+
+    "semver": ["semver@7.8.0", "", { "bin": "bin/semver.js" }, "sha512-AcM7dV/5ul4EekoQ29Agm5vri8JNqRyj39o0qpX6vDF2GZrtutZl5RwgD1XnZjiTAfncsJhMI48QQH3sN87YNA=="],
+
+    "shell-quote": ["shell-quote@1.8.3", "", {}, "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw=="],
+
+    "signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="],
+
+    "string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "strip-ansi": ["strip-ansi@7.1.2", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA=="],
+
+    "supports-color": ["supports-color@8.1.1", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="],
+
+    "tinyglobby": ["tinyglobby@0.2.16", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.4" } }, "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg=="],
+
+    "tsx": ["tsx@4.21.0", "", { "dependencies": { "esbuild": "~0.27.0", "get-tsconfig": "^4.7.5" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "bin": "dist/cli.mjs" }, "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw=="],
+
+    "type-fest": ["type-fest@0.21.3", "", {}, "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w=="],
+
+    "typescript": ["typescript@6.0.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw=="],
+
+    "undici-types": ["undici-types@7.21.0", "", {}, "sha512-w9IMgQrz4O0YN1LtB7K5P63vhlIOvC7opSmouCJ+ZywlPAlO9gIkJ+otk6LvGpAs2wg4econaCz3TvQ9xPoyuQ=="],
+
+    "web-tree-sitter": ["web-tree-sitter@0.25.10", "", { "peerDependencies": { "@types/emscripten": "^1.40.0" }, "optionalPeers": ["@types/emscripten"] }, "sha512-Y09sF44/13XvgVKgO2cNDw5rGk6s26MgoZPXLESvMXeefBf7i6/73eFurre0IsTW6E14Y0ArIzhUMmjoc7xyzA=="],
+
+    "widest-line": ["widest-line@3.1.0", "", { "dependencies": { "string-width": "^4.0.0" } }, "sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg=="],
+
+    "wordwrap": ["wordwrap@1.0.0", "", {}, "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q=="],
+
+    "wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
+
+    "ws": ["ws@8.20.1", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-It4dO0K5v//JtTXuPkfEOaI3uUN87iYPnqo/ZzqCoG3g8uhA66QUMs/SrM0YK7/NAu+r4LMh/9dq2A7k+rHs+w=="],
+
+    "yoctocolors-cjs": ["yoctocolors-cjs@2.1.3", "", {}, "sha512-U/PBtDf35ff0D8X8D0jfdzHYEPFxAI7jJlxZXwCSez5M3190m+QobIfh+sWDWSHMCWWJN2AWamkegn6vr6YBTw=="],
+
+    "yoga-layout": ["yoga-layout@3.2.1", "", {}, "sha512-0LPOt3AxKqMdFBZA3HBAt/t/8vIKq7VaQYbuA8WxCgung+p9TVyKRYdpvCb80HcdTN2NkbIKbhNwKUfm3tQywQ=="],
+
+    "@inquirer/core/wrap-ansi": ["wrap-ansi@6.2.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA=="],
+
+    "@opentui/core/string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="],
+
+    "filelist/minimatch": ["minimatch@5.1.9", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw=="],
+
+    "react-devtools-core/ws": ["ws@7.5.10", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": "^5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ=="],
+
+    "string-width/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "wrap-ansi/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "@inquirer/core/wrap-ansi/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "@opentui/core/string-width/emoji-regex": ["emoji-regex@10.6.0", "", {}, "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A=="],
+
+    "filelist/minimatch/brace-expansion": ["brace-expansion@2.1.0", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w=="],
+
+    "string-width/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "wrap-ansi/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "@inquirer/core/wrap-ansi/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "filelist/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],
+  }
+}
diff --git a/cmd/beeper-desktop-cli/main.go b/cmd/beeper-desktop-cli/main.go
deleted file mode 100644
index e27225a..0000000
--- a/cmd/beeper-desktop-cli/main.go
+++ /dev/null
@@ -1,62 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"os"
-	"slices"
-
-	"github.com/beeper/desktop-api-cli/pkg/cmd"
-	"github.com/beeper/desktop-api-go"
-	"github.com/tidwall/gjson"
-	"github.com/urfave/cli/v3"
-)
-
-func main() {
-	app := cmd.Command
-
-	if slices.Contains(os.Args, "__complete") {
-		prepareForAutocomplete(app)
-	}
-
-	if err := app.Run(context.Background(), os.Args); err != nil {
-		exitCode := 1
-
-		// Check if error has a custom exit code
-		if exitErr, ok := err.(cli.ExitCoder); ok {
-			exitCode = exitErr.ExitCode()
-		}
-
-		var apierr *beeperdesktopapi.Error
-		if errors.As(err, &apierr) {
-			fmt.Fprintf(os.Stderr, "%s %q: %d %s\n", apierr.Request.Method, apierr.Request.URL, apierr.Response.StatusCode, http.StatusText(apierr.Response.StatusCode))
-			format := app.String("format-error")
-			json := gjson.Parse(apierr.RawJSON())
-			show_err := cmd.ShowJSON(os.Stdout, "Error", json, format, app.String("transform-error"))
-			if show_err != nil {
-				// Just print the original error:
-				fmt.Fprintf(os.Stderr, "%s\n", err.Error())
-			}
-		} else {
-			if cmd.CommandErrorBuffer.Len() > 0 {
-				os.Stderr.Write(cmd.CommandErrorBuffer.Bytes())
-			} else {
-				fmt.Fprintf(os.Stderr, "%s\n", err.Error())
-			}
-		}
-		os.Exit(exitCode)
-	}
-}
-
-func prepareForAutocomplete(cmd *cli.Command) {
-	// urfave/cli does not handle flag completions and will print an error if we inspect a command with invalid flags.
-	// This skips that sort of validation
-	cmd.SkipFlagParsing = true
-	for _, child := range cmd.Commands {
-		prepareForAutocomplete(child)
-	}
-}
diff --git a/go.mod b/go.mod
deleted file mode 100644
index 4d42343..0000000
--- a/go.mod
+++ /dev/null
@@ -1,46 +0,0 @@
-module github.com/beeper/desktop-api-cli
-
-go 1.25
-
-require (
-	github.com/beeper/desktop-api-go v0.5.0
-	github.com/charmbracelet/bubbles v0.21.0
-	github.com/charmbracelet/bubbletea v1.3.6
-	github.com/charmbracelet/lipgloss v1.1.0
-	github.com/charmbracelet/x/term v0.2.1
-	github.com/goccy/go-yaml v1.18.0
-	github.com/itchyny/json2yaml v0.1.4
-	github.com/muesli/reflow v0.3.0
-	github.com/stretchr/testify v1.10.0
-	github.com/tidwall/gjson v1.18.0
-	github.com/tidwall/pretty v1.2.1
-	github.com/urfave/cli-docs/v3 v3.0.0-alpha6
-	github.com/urfave/cli/v3 v3.3.2
-	golang.org/x/sys v0.38.0
-)
-
-require (
-	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
-	github.com/charmbracelet/x/ansi v0.9.3 // indirect
-	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
-	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-localereader v0.0.1 // indirect
-	github.com/mattn/go-runewidth v0.0.16 // indirect
-	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
-	github.com/muesli/cancelreader v0.2.2 // indirect
-	github.com/muesli/termenv v0.16.0 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/tidwall/match v1.1.1 // indirect
-	github.com/tidwall/sjson v1.2.5 // indirect
-	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	golang.org/x/sync v0.15.0 // indirect
-	golang.org/x/text v0.3.8 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)
diff --git a/go.sum b/go.sum
deleted file mode 100644
index c6fed8f..0000000
--- a/go.sum
+++ /dev/null
@@ -1,89 +0,0 @@
-github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
-github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
-github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8=
-github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
-github.com/beeper/desktop-api-go v0.5.0 h1:0Myrz8eop5dC3/QseUrbYVIyWkHPGLyU47/lffw/kT4=
-github.com/beeper/desktop-api-go v0.5.0/go.mod h1:y9Mk83OdQWo6ldLTcPyaUPrwjkmvy/3QkhHqZLhU/mA=
-github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
-github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
-github.com/charmbracelet/bubbletea v1.3.6 h1:VkHIxPJQeDt0aFJIsVxw8BQdh/F/L2KKZGsK6et5taU=
-github.com/charmbracelet/bubbletea v1.3.6/go.mod h1:oQD9VCRQFF8KplacJLo28/jofOI2ToOfGYeFgBBxHOc=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs=
-github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk=
-github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
-github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
-github.com/charmbracelet/x/ansi v0.9.3 h1:BXt5DHS/MKF+LjuK4huWrC6NCvHtexww7dMayh6GXd0=
-github.com/charmbracelet/x/ansi v0.9.3/go.mod h1:3RQDQ6lDnROptfpWuUVIUG64bD2g2BgntdxH0Ya5TeE=
-github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd h1:vy0GVL4jeHEwG5YOXDmi86oYw2yuYUGqz6a8sLwg0X8=
-github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
-github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91 h1:payRxjMjKgx2PaCWLZ4p3ro9y97+TVLZNaRZgJwSVDQ=
-github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
-github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
-github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
-github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
-github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
-github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
-github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
-github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
-github.com/itchyny/json2yaml v0.1.4 h1:/pErVOXGG5iTyXHi/QKR4y3uzhLjGTEmmJIy97YT+k8=
-github.com/itchyny/json2yaml v0.1.4/go.mod h1:6iudhBZdarpjLFRNj+clWLAkGft+9uCcjAZYXUH9eGI=
-github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
-github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
-github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
-github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
-github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
-github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
-github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
-github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
-github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
-github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
-github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
-github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
-github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
-github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/tidwall/gjson v1.14.2/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
-github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
-github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
-github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
-github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
-github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
-github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
-github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
-github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
-github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
-github.com/urfave/cli-docs/v3 v3.0.0-alpha6 h1:w/l/N0xw1rO/aHRIGXJ0lDwwYFOzilup1qGvIytP3BI=
-github.com/urfave/cli-docs/v3 v3.0.0-alpha6/go.mod h1:p7Z4lg8FSTrPB9GTaNyTrK3ygffHZcK3w0cU2VE+mzU=
-github.com/urfave/cli/v3 v3.3.2 h1:BYFVnhhZ8RqT38DxEYVFPPmGFTEf7tJwySTXsVRrS/o=
-github.com/urfave/cli/v3 v3.3.2/go.mod h1:FJSKtM/9AiiTOJL4fJ6TbMUkxBXn7GO9guZqoZtpYpo=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
-github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
-golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561 h1:MDc5xs78ZrZr3HMQugiXOAkSZtfTpbJLDr/lwfgO53E=
-golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
-golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
-golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
-golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
-golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/internal/apiform/encoder.go b/internal/apiform/encoder.go
deleted file mode 100644
index 857fe14..0000000
--- a/internal/apiform/encoder.go
+++ /dev/null
@@ -1,236 +0,0 @@
-package apiform
-
-import (
-	"fmt"
-	"io"
-	"mime/multipart"
-	"net/textproto"
-	"path"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-// Marshal encodes a value as multipart form data using default settings
-func Marshal(value any, writer *multipart.Writer) error {
-	e := &encoder{
-		format: FormatRepeat,
-	}
-	return e.marshal(value, writer)
-}
-
-// MarshalWithSettings encodes a value with custom array format
-func MarshalWithSettings(value any, writer *multipart.Writer, arrayFormat FormFormat) error {
-	e := &encoder{
-		format: arrayFormat,
-	}
-	return e.marshal(value, writer)
-}
-
-type encoder struct {
-	format FormFormat
-}
-
-func (e *encoder) marshal(value any, writer *multipart.Writer) error {
-	val := reflect.ValueOf(value)
-	if !val.IsValid() {
-		return nil
-	}
-	return e.encodeValue("", val, writer)
-}
-
-func (e *encoder) encodeValue(key string, val reflect.Value, writer *multipart.Writer) error {
-	if !val.IsValid() {
-		return writer.WriteField(key, "")
-	}
-
-	t := val.Type()
-
-	if t.Implements(reflect.TypeOf((*io.Reader)(nil)).Elem()) {
-		return e.encodeReader(key, val, writer)
-	}
-
-	switch t.Kind() {
-	case reflect.Pointer:
-		if val.IsNil() || !val.IsValid() {
-			return writer.WriteField(key, "")
-		}
-		return e.encodeValue(key, val.Elem(), writer)
-
-	case reflect.Slice, reflect.Array:
-		return e.encodeArray(key, val, writer)
-
-	case reflect.Map:
-		return e.encodeMap(key, val, writer)
-
-	case reflect.Interface:
-		if val.IsNil() {
-			return writer.WriteField(key, "")
-		}
-		return e.encodeValue(key, val.Elem(), writer)
-
-	case reflect.String:
-		return writer.WriteField(key, val.String())
-
-	case reflect.Bool:
-		if val.Bool() {
-			return writer.WriteField(key, "true")
-		}
-		return writer.WriteField(key, "false")
-
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return writer.WriteField(key, strconv.FormatInt(val.Int(), 10))
-
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return writer.WriteField(key, strconv.FormatUint(val.Uint(), 10))
-
-	case reflect.Float32:
-		return writer.WriteField(key, strconv.FormatFloat(val.Float(), 'f', -1, 32))
-
-	case reflect.Float64:
-		return writer.WriteField(key, strconv.FormatFloat(val.Float(), 'f', -1, 64))
-
-	default:
-		return fmt.Errorf("unknown type: %s", t.String())
-	}
-}
-
-func (e *encoder) encodeArray(key string, val reflect.Value, writer *multipart.Writer) error {
-	if e.format == FormatComma {
-		var values []string
-		for i := 0; i < val.Len(); i++ {
-			item := val.Index(i)
-			if (item.Kind() == reflect.Pointer || item.Kind() == reflect.Interface) && item.IsNil() {
-				// Null values are sent as an empty string
-				values = append(values, "")
-				continue
-			}
-			// If item is an interface, reduce it to the concrete type
-			if item.Kind() == reflect.Interface {
-				item = item.Elem()
-			}
-			var strValue string
-			switch item.Kind() {
-			case reflect.String:
-				strValue = item.String()
-			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				strValue = strconv.FormatInt(item.Int(), 10)
-			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-				strValue = strconv.FormatUint(item.Uint(), 10)
-			case reflect.Float32, reflect.Float64:
-				strValue = strconv.FormatFloat(item.Float(), 'f', -1, 64)
-			case reflect.Bool:
-				strValue = strconv.FormatBool(item.Bool())
-			default:
-				return fmt.Errorf("comma format not supported for complex array elements")
-			}
-			values = append(values, strValue)
-		}
-		return writer.WriteField(key, strings.Join(values, ","))
-	}
-
-	for i := 0; i < val.Len(); i++ {
-		var formattedKey string
-		switch e.format {
-		case FormatRepeat:
-			formattedKey = key
-		case FormatBrackets:
-			formattedKey = key + "[]"
-		case FormatIndicesDots:
-			if key == "" {
-				formattedKey = strconv.Itoa(i)
-			} else {
-				formattedKey = key + "." + strconv.Itoa(i)
-			}
-		case FormatIndicesBrackets:
-			if key == "" {
-				formattedKey = strconv.Itoa(i)
-			} else {
-				formattedKey = key + "[" + strconv.Itoa(i) + "]"
-			}
-		default:
-			return fmt.Errorf("apiform: unsupported array format")
-		}
-
-		if err := e.encodeValue(formattedKey, val.Index(i), writer); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-var quoteEscaper = strings.NewReplacer("\\", "\\\\", `"`, "\\\"")
-
-func escapeQuotes(s string) string {
-	return quoteEscaper.Replace(s)
-}
-
-func (e *encoder) encodeReader(key string, val reflect.Value, writer *multipart.Writer) error {
-	reader, ok := val.Convert(reflect.TypeOf((*io.Reader)(nil)).Elem()).Interface().(io.Reader)
-	if !ok {
-		return nil
-	}
-
-	// Set defaults
-	filename := "anonymous_file"
-	contentType := "application/octet-stream"
-
-	// Get filename if available
-	if named, ok := reader.(interface{ Filename() string }); ok {
-		filename = named.Filename()
-	} else if named, ok := reader.(interface{ Name() string }); ok {
-		filename = path.Base(named.Name())
-	}
-
-	// Get content type if available
-	if typed, ok := reader.(interface{ ContentType() string }); ok {
-		contentType = typed.ContentType()
-	}
-
-	h := make(textproto.MIMEHeader)
-	h.Set("Content-Disposition", fmt.Sprintf(`form-data; name="%s"; filename="%s"`,
-		escapeQuotes(key), escapeQuotes(filename)))
-	h.Set("Content-Type", contentType)
-
-	filewriter, err := writer.CreatePart(h)
-	if err != nil {
-		return err
-	}
-	_, err = io.Copy(filewriter, reader)
-	return err
-}
-
-func (e *encoder) encodeMap(key string, val reflect.Value, writer *multipart.Writer) error {
-	type mapPair struct {
-		key   string
-		value reflect.Value
-	}
-
-	if key != "" {
-		key = key + "."
-	}
-
-	// Collect and sort map entries for deterministic output
-	pairs := []mapPair{}
-	iter := val.MapRange()
-	for iter.Next() {
-		if iter.Key().Type().Kind() != reflect.String {
-			return fmt.Errorf("cannot encode a map with a non string key")
-		}
-		pairs = append(pairs, mapPair{key: iter.Key().String(), value: iter.Value()})
-	}
-
-	sort.Slice(pairs, func(i, j int) bool {
-		return pairs[i].key < pairs[j].key
-	})
-
-	// Process sorted pairs
-	for _, p := range pairs {
-		if err := e.encodeValue(key+p.key, p.value, writer); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
diff --git a/internal/apiform/form.go b/internal/apiform/form.go
deleted file mode 100644
index 024de27..0000000
--- a/internal/apiform/form.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package apiform
-
-type Marshaler interface {
-	MarshalMultipart() ([]byte, string, error)
-}
-
-type FormFormat int
-
-const (
-	// FormatRepeat represents arrays as repeated keys with the same value
-	FormatRepeat FormFormat = iota
-	// Comma-separated values 1,2,3
-	FormatComma
-	// FormatBrackets uses the key[] notation for arrays
-	FormatBrackets
-	// FormatIndicesDots uses key.0, key.1, etc. notation
-	FormatIndicesDots
-	// FormatIndicesBrackets uses key[0], key[1], etc. notation
-	FormatIndicesBrackets
-)
diff --git a/internal/apiform/form_test.go b/internal/apiform/form_test.go
deleted file mode 100644
index 2cf5bdd..0000000
--- a/internal/apiform/form_test.go
+++ /dev/null
@@ -1,109 +0,0 @@
-package apiform
-
-import (
-	"bytes"
-	"mime/multipart"
-	"testing"
-)
-
-// Define test cases
-var tests = map[string]struct {
-	value    any
-	format   FormFormat
-	expected string
-}{
-	"nil": {
-		value:    nil,
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo\"\r\n\r\n\r\n--xxx--\r\n",
-	},
-	"string": {
-		value:    "hello",
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo\"\r\n\r\nhello\r\n--xxx--\r\n",
-	},
-	"int": {
-		value:    42,
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo\"\r\n\r\n42\r\n--xxx--\r\n",
-	},
-	"float": {
-		value:    3.14,
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo\"\r\n\r\n3.14\r\n--xxx--\r\n",
-	},
-	"bool": {
-		value:    true,
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo\"\r\n\r\ntrue\r\n--xxx--\r\n",
-	},
-	"empty slice": {
-		value:    []string{},
-		expected: "\r\n--xxx--\r\n",
-	},
-	"nil slice": {
-		value:    []string(nil),
-		expected: "\r\n--xxx--\r\n",
-	},
-	"slice with dot indices": {
-		value:    []string{"a", "b", "c"},
-		format:   FormatIndicesDots,
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo.0\"\r\n\r\na\r\n--xxx\r\nContent-Disposition: form-data; name=\"foo.1\"\r\n\r\nb\r\n--xxx\r\nContent-Disposition: form-data; name=\"foo.2\"\r\n\r\nc\r\n--xxx--\r\n",
-	},
-	"slice with bracket indices": {
-		value:    []int{10, 20, 30},
-		format:   FormatIndicesBrackets,
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo[0]\"\r\n\r\n10\r\n--xxx\r\nContent-Disposition: form-data; name=\"foo[1]\"\r\n\r\n20\r\n--xxx\r\nContent-Disposition: form-data; name=\"foo[2]\"\r\n\r\n30\r\n--xxx--\r\n",
-	},
-	"slice with repeat": {
-		value:    []int{10, 20, 30},
-		format:   FormatRepeat,
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo\"\r\n\r\n10\r\n--xxx\r\nContent-Disposition: form-data; name=\"foo\"\r\n\r\n20\r\n--xxx\r\nContent-Disposition: form-data; name=\"foo\"\r\n\r\n30\r\n--xxx--\r\n",
-	},
-	"slice with commas": {
-		value:    []int{10, 20, 30},
-		format:   FormatComma,
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo\"\r\n\r\n10,20,30\r\n--xxx--\r\n",
-	},
-	"empty map": {
-		value:    map[string]any{},
-		expected: "\r\n--xxx--\r\n",
-	},
-	"nil map": {
-		value:    map[string]any(nil),
-		expected: "\r\n--xxx--\r\n",
-	},
-	"map": {
-		value:    map[string]any{"key1": "value1", "key2": "value2"},
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo.key1\"\r\n\r\nvalue1\r\n--xxx\r\nContent-Disposition: form-data; name=\"foo.key2\"\r\n\r\nvalue2\r\n--xxx--\r\n",
-	},
-	"nested_map": {
-		value:    map[string]any{"outer": map[string]int{"inner1": 10, "inner2": 20}},
-		format:   FormatIndicesDots,
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo.outer.inner1\"\r\n\r\n10\r\n--xxx\r\nContent-Disposition: form-data; name=\"foo.outer.inner2\"\r\n\r\n20\r\n--xxx--\r\n",
-	},
-	"mixed_map": {
-		value:    map[string]any{"name": "John", "ages": []int{25, 30, 35}},
-		format:   FormatIndicesDots,
-		expected: "--xxx\r\nContent-Disposition: form-data; name=\"foo.ages.0\"\r\n\r\n25\r\n--xxx\r\nContent-Disposition: form-data; name=\"foo.ages.1\"\r\n\r\n30\r\n--xxx\r\nContent-Disposition: form-data; name=\"foo.ages.2\"\r\n\r\n35\r\n--xxx\r\nContent-Disposition: form-data; name=\"foo.name\"\r\n\r\nJohn\r\n--xxx--\r\n",
-	},
-}
-
-func TestEncode(t *testing.T) {
-	for name, test := range tests {
-		t.Run(name, func(t *testing.T) {
-			buf := bytes.NewBuffer(nil)
-			writer := multipart.NewWriter(buf)
-			writer.SetBoundary("xxx")
-
-			form := map[string]any{"foo": test.value}
-			err := MarshalWithSettings(form, writer, test.format)
-			if err != nil {
-				t.Errorf("serialization of %v failed with error %v", test.value, err)
-			}
-			err = writer.Close()
-			if err != nil {
-				t.Errorf("serialization of %v failed with error %v", test.value, err)
-			}
-			result := buf.String()
-			if result != test.expected {
-				t.Errorf("expected %+#v to serialize to:\n\t%q\nbut got:\n\t%q", test.value, test.expected, result)
-			}
-		})
-	}
-}
diff --git a/internal/apiquery/encoder.go b/internal/apiquery/encoder.go
deleted file mode 100644
index 0d09dee..0000000
--- a/internal/apiquery/encoder.go
+++ /dev/null
@@ -1,166 +0,0 @@
-package apiquery
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-)
-
-type encoder struct {
-	settings QuerySettings
-}
-
-type Pair struct {
-	key   string
-	value string
-}
-
-func (e *encoder) Encode(key string, value reflect.Value) ([]Pair, error) {
-	t := value.Type()
-	switch t.Kind() {
-	case reflect.Pointer:
-		if value.IsNil() || !value.IsValid() {
-			return []Pair{{key, ""}}, nil
-		}
-		return e.Encode(key, value.Elem())
-
-	case reflect.Array, reflect.Slice:
-		return e.encodeArray(key, value)
-
-	case reflect.Map:
-		return e.encodeMap(key, value)
-
-	case reflect.Interface:
-		if !value.Elem().IsValid() {
-			return []Pair{{key, ""}}, nil
-		}
-		return e.Encode(key, value.Elem())
-
-	default:
-		return e.encodePrimitive(key, value)
-	}
-}
-
-func (e *encoder) encodeMap(key string, value reflect.Value) ([]Pair, error) {
-	var pairs []Pair
-	iter := value.MapRange()
-	for iter.Next() {
-		subkey := iter.Key().String()
-		keyPath := subkey
-		if len(key) > 0 {
-			if e.settings.NestedFormat == NestedQueryFormatDots {
-				keyPath = fmt.Sprintf("%s.%s", key, subkey)
-			} else {
-				keyPath = fmt.Sprintf("%s[%s]", key, subkey)
-			}
-		}
-
-		subpairs, err := e.Encode(keyPath, iter.Value())
-		if err != nil {
-			return nil, err
-		}
-		pairs = append(pairs, subpairs...)
-	}
-	return pairs, nil
-}
-
-func (e *encoder) encodeArray(key string, value reflect.Value) ([]Pair, error) {
-	switch e.settings.ArrayFormat {
-	case ArrayQueryFormatComma:
-		elements := []string{}
-		for i := 0; i < value.Len(); i++ {
-			innerPairs, err := e.Encode("", value.Index(i))
-			if err != nil {
-				return nil, err
-			}
-			for _, pair := range innerPairs {
-				elements = append(elements, pair.value)
-			}
-		}
-		return []Pair{{key, strings.Join(elements, ",")}}, nil
-
-	case ArrayQueryFormatRepeat:
-		var pairs []Pair
-		for i := 0; i < value.Len(); i++ {
-			subpairs, err := e.Encode(key, value.Index(i))
-			if err != nil {
-				return nil, err
-			}
-			pairs = append(pairs, subpairs...)
-		}
-		return pairs, nil
-
-	case ArrayQueryFormatIndices:
-		var pairs []Pair
-		for i := 0; i < value.Len(); i++ {
-			subpairs, err := e.Encode(fmt.Sprintf("%s[%d]", key, i), value.Index(i))
-			if err != nil {
-				return nil, err
-			}
-			pairs = append(pairs, subpairs...)
-		}
-		return pairs, nil
-
-	case ArrayQueryFormatBrackets:
-		var pairs []Pair
-		for i := 0; i < value.Len(); i++ {
-			subpairs, err := e.Encode(key+"[]", value.Index(i))
-			if err != nil {
-				return nil, err
-			}
-			pairs = append(pairs, subpairs...)
-		}
-		return pairs, nil
-
-	default:
-		panic(fmt.Sprintf("Unknown ArrayFormat value: %d", e.settings.ArrayFormat))
-	}
-}
-
-func (e *encoder) encodePrimitive(key string, value reflect.Value) ([]Pair, error) {
-	switch value.Kind() {
-	case reflect.Pointer:
-		if !value.IsValid() || value.IsNil() {
-			return nil, nil
-		}
-		return e.encodePrimitive(key, value.Elem())
-
-	case reflect.String:
-		return []Pair{{key, value.String()}}, nil
-
-	case reflect.Bool:
-		if value.Bool() {
-			return []Pair{{key, "true"}}, nil
-		}
-		return []Pair{{key, "false"}}, nil
-
-	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
-		return []Pair{{key, strconv.FormatInt(value.Int(), 10)}}, nil
-
-	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return []Pair{{key, strconv.FormatUint(value.Uint(), 10)}}, nil
-
-	case reflect.Float32, reflect.Float64:
-		return []Pair{{key, strconv.FormatFloat(value.Float(), 'f', -1, 64)}}, nil
-
-	default:
-		return nil, nil
-	}
-}
-
-func (e *encoder) encodeField(key string, value reflect.Value) ([]Pair, error) {
-	present := value.FieldByName("Present")
-	if !present.Bool() {
-		return nil, nil
-	}
-	null := value.FieldByName("Null")
-	if null.Bool() {
-		return nil, fmt.Errorf("apiquery: field cannot be null")
-	}
-	raw := value.FieldByName("Raw")
-	if !raw.IsNil() {
-		return e.Encode(key, raw)
-	}
-	return e.Encode(key, value.FieldByName("Value"))
-}
diff --git a/internal/apiquery/query.go b/internal/apiquery/query.go
deleted file mode 100644
index fd07a2f..0000000
--- a/internal/apiquery/query.go
+++ /dev/null
@@ -1,53 +0,0 @@
-package apiquery
-
-import (
-	"net/url"
-	"reflect"
-)
-
-func MarshalWithSettings(value any, settings QuerySettings) (url.Values, error) {
-	val := reflect.ValueOf(value)
-	if !val.IsValid() {
-		return nil, nil
-	}
-
-	e := encoder{settings}
-	pairs, err := e.Encode("", val)
-	if err != nil {
-		return nil, err
-	}
-
-	kv := url.Values{}
-	for _, pair := range pairs {
-		kv.Add(pair.key, pair.value)
-	}
-	return kv, nil
-}
-func Marshal(value any) (url.Values, error) {
-	return MarshalWithSettings(value, QuerySettings{})
-}
-
-type Queryer interface {
-	URLQuery() (url.Values, error)
-}
-
-type NestedQueryFormat int
-
-const (
-	NestedQueryFormatBrackets NestedQueryFormat = iota
-	NestedQueryFormatDots
-)
-
-type ArrayQueryFormat int
-
-const (
-	ArrayQueryFormatComma ArrayQueryFormat = iota
-	ArrayQueryFormatRepeat
-	ArrayQueryFormatIndices
-	ArrayQueryFormatBrackets
-)
-
-type QuerySettings struct {
-	NestedFormat NestedQueryFormat
-	ArrayFormat  ArrayQueryFormat
-}
diff --git a/internal/apiquery/query_test.go b/internal/apiquery/query_test.go
deleted file mode 100644
index 8bee784..0000000
--- a/internal/apiquery/query_test.go
+++ /dev/null
@@ -1,128 +0,0 @@
-package apiquery
-
-import (
-	"net/url"
-	"testing"
-)
-
-func TestEncode(t *testing.T) {
-	tests := map[string]struct {
-		val      any
-		settings QuerySettings
-		enc      string
-	}{
-		"null": {
-			val: nil,
-			enc: "query=",
-		},
-		"string": {
-			val: "hello world",
-			enc: "query=hello world",
-		},
-		"int": {
-			val: 42,
-			enc: "query=42",
-		},
-		"float": {
-			val: 3.14,
-			enc: "query=3.14",
-		},
-		"bool": {
-			val: true,
-			enc: "query=true",
-		},
-		"empty_slice": {
-			val:      []any{},
-			settings: QuerySettings{ArrayFormat: ArrayQueryFormatComma},
-			enc:      "query=",
-		},
-		"nil_slice": {
-			val:      []any(nil),
-			settings: QuerySettings{ArrayFormat: ArrayQueryFormatComma},
-			enc:      "query=",
-		},
-		"slice_of_ints": {
-			val:      []any{10, 20, 30},
-			settings: QuerySettings{ArrayFormat: ArrayQueryFormatComma},
-			enc:      "query=10,20,30",
-		},
-		"slice_of_ints_repeat": {
-			val:      []any{10, 20, 30},
-			settings: QuerySettings{ArrayFormat: ArrayQueryFormatRepeat},
-			enc:      "query=10&query=20&query=30",
-		},
-		"slice_of_ints_indices": {
-			val:      []any{10, 20, 30},
-			settings: QuerySettings{ArrayFormat: ArrayQueryFormatIndices},
-			enc:      "query[0]=10&query[1]=20&query[2]=30",
-		},
-		"slice_of_ints_brackets": {
-			val:      []any{10, 20, 30},
-			settings: QuerySettings{ArrayFormat: ArrayQueryFormatBrackets},
-			enc:      "query[]=10&query[]=20&query[]=30",
-		},
-		"slice_of_strings": {
-			val:      []any{"a", "b", "c"},
-			settings: QuerySettings{},
-			enc:      "query=a,b,c",
-		},
-		"empty_map": {
-			val:      map[string]any{},
-			settings: QuerySettings{NestedFormat: NestedQueryFormatBrackets},
-			enc:      "",
-		},
-		"nil_map": {
-			val:      map[string]any(nil),
-			settings: QuerySettings{NestedFormat: NestedQueryFormatBrackets},
-			enc:      "",
-		},
-		"map_string_to_int_brackets": {
-			val:      map[string]any{"one": 1, "two": 2},
-			settings: QuerySettings{NestedFormat: NestedQueryFormatBrackets},
-			enc:      "query[one]=1&query[two]=2",
-		},
-		"map_string_to_int_dots": {
-			val:      map[string]any{"one": 1, "two": 2},
-			settings: QuerySettings{NestedFormat: NestedQueryFormatDots},
-			enc:      "query.one=1&query.two=2",
-		},
-		"map_string_to_slice": {
-			val:      map[string][]any{"nums": {10, 20, 30}},
-			settings: QuerySettings{},
-			enc:      "query[nums]=10,20,30",
-		},
-		"map_string_to_slice_repeat_dots": {
-			val:      map[string][]any{"nums": {10, 20, 30}},
-			settings: QuerySettings{ArrayFormat: ArrayQueryFormatRepeat, NestedFormat: NestedQueryFormatDots},
-			enc:      "query.nums=10&query.nums=20&query.nums=30",
-		},
-		"map_with_empties": {
-			val: map[string]any{
-				"empty-array": []any{},
-				"nil-array":   []any(nil),
-				"null":        nil,
-			},
-			settings: QuerySettings{ArrayFormat: ArrayQueryFormatComma, NestedFormat: NestedQueryFormatDots},
-			enc:      "query.empty-array=&query.nil-array=&query.null=",
-		},
-		"nested_map": {
-			val:      map[string]map[string]any{"outer": {"inner": 42}},
-			settings: QuerySettings{},
-			enc:      "query[outer][inner]=42",
-		},
-	}
-
-	for name, test := range tests {
-		t.Run(name, func(t *testing.T) {
-			query := map[string]any{"query": test.val}
-			values, err := MarshalWithSettings(query, test.settings)
-			if err != nil {
-				t.Fatalf("failed to marshal url %s", err)
-			}
-			str, _ := url.QueryUnescape(values.Encode())
-			if str != test.enc {
-				t.Fatalf("expected %+#v to serialize to:\n\t%q\nbut got:\n\t%q", test.val, test.enc, str)
-			}
-		})
-	}
-}
diff --git a/internal/autocomplete/autocomplete.go b/internal/autocomplete/autocomplete.go
deleted file mode 100644
index 97fe1a8..0000000
--- a/internal/autocomplete/autocomplete.go
+++ /dev/null
@@ -1,361 +0,0 @@
-package autocomplete
-
-import (
-	"context"
-	"embed"
-	"fmt"
-	"os"
-	"slices"
-	"strings"
-
-	"github.com/urfave/cli/v3"
-)
-
-type CompletionStyle string
-
-const (
-	CompletionStyleZsh        CompletionStyle = "zsh"
-	CompletionStyleBash       CompletionStyle = "bash"
-	CompletionStylePowershell CompletionStyle = "pwsh"
-	CompletionStyleFish       CompletionStyle = "fish"
-)
-
-type renderCompletion func(cmd *cli.Command, appName string) (string, error)
-
-var (
-	//go:embed shellscripts
-	autoCompleteFS embed.FS
-
-	shellCompletions = map[CompletionStyle]renderCompletion{
-		"bash": func(c *cli.Command, appName string) (string, error) {
-			b, err := autoCompleteFS.ReadFile("shellscripts/bash_autocomplete.bash")
-			return strings.ReplaceAll(string(b), "__APPNAME__", appName), err
-		},
-		"fish": func(c *cli.Command, appName string) (string, error) {
-			b, err := autoCompleteFS.ReadFile("shellscripts/fish_autocomplete.fish")
-			return strings.ReplaceAll(string(b), "__APPNAME__", appName), err
-		},
-		"pwsh": func(c *cli.Command, appName string) (string, error) {
-			b, err := autoCompleteFS.ReadFile("shellscripts/pwsh_autocomplete.ps1")
-			return strings.ReplaceAll(string(b), "__APPNAME__", appName), err
-		},
-		"zsh": func(c *cli.Command, appName string) (string, error) {
-			b, err := autoCompleteFS.ReadFile("shellscripts/zsh_autocomplete.zsh")
-			return strings.ReplaceAll(string(b), "__APPNAME__", appName), err
-		},
-	}
-)
-
-func OutputCompletionScript(ctx context.Context, cmd *cli.Command) error {
-	shells := make([]CompletionStyle, 0, len(shellCompletions))
-	for k := range shellCompletions {
-		shells = append(shells, k)
-	}
-
-	if cmd.Args().Len() == 0 {
-		return cli.Exit(fmt.Sprintf("no shell provided for completion command. available shells are %+v", shells), 1)
-	}
-	s := CompletionStyle(cmd.Args().First())
-
-	renderCompletion, ok := shellCompletions[s]
-	if !ok {
-		return cli.Exit(fmt.Sprintf("unknown shell %s, available shells are %+v", s, shells), 1)
-	}
-
-	completionScript, err := renderCompletion(cmd, cmd.Root().Name)
-	if err != nil {
-		return cli.Exit(err, 1)
-	}
-
-	_, err = cmd.Writer.Write([]byte(completionScript))
-	if err != nil {
-		return cli.Exit(err, 1)
-	}
-
-	return nil
-}
-
-type ShellCompletion struct {
-	Name  string
-	Usage string
-}
-
-func NewShellCompletion(name string, usage string) ShellCompletion {
-	return ShellCompletion{Name: name, Usage: usage}
-}
-
-type ShellCompletionBehavior int
-
-const (
-	ShellCompletionBehaviorDefault ShellCompletionBehavior = iota
-	ShellCompletionBehaviorFile                            = 10
-	ShellCompletionBehaviorNoComplete
-)
-
-type CompletionResult struct {
-	Completions []ShellCompletion
-	Behavior    ShellCompletionBehavior
-}
-
-func isFlag(arg string) bool {
-	return strings.HasPrefix(arg, "-")
-}
-
-func findFlag(cmd *cli.Command, arg string) *cli.Flag {
-	name := strings.TrimLeft(arg, "-")
-	for _, flag := range cmd.Flags {
-		if vf, ok := flag.(cli.VisibleFlag); ok && !vf.IsVisible() {
-			continue
-		}
-
-		if slices.Contains(flag.Names(), name) {
-			return &flag
-		}
-	}
-	return nil
-}
-
-func findChild(cmd *cli.Command, name string) *cli.Command {
-	for _, c := range cmd.Commands {
-		if !c.Hidden && c.Name == name {
-			return c
-		}
-	}
-	return nil
-}
-
-type shellCompletionBuilder struct {
-	completionStyle CompletionStyle
-}
-
-func (scb *shellCompletionBuilder) createFromCommand(input string, command *cli.Command, result []ShellCompletion) []ShellCompletion {
-	matchingNames := make([]string, 0, len(command.Names()))
-
-	for _, name := range command.Names() {
-		if strings.HasPrefix(name, input) {
-			matchingNames = append(matchingNames, name)
-		}
-	}
-
-	if scb.completionStyle == CompletionStyleBash {
-		index := strings.LastIndex(input, ":") + 1
-		if index > 0 {
-			for _, name := range matchingNames {
-				result = append(result, NewShellCompletion(name[index:], command.Usage))
-			}
-			return result
-		}
-	}
-
-	for _, name := range matchingNames {
-		result = append(result, NewShellCompletion(name, command.Usage))
-	}
-	return result
-}
-
-func (scb *shellCompletionBuilder) createFromFlag(input string, flag *cli.Flag, result []ShellCompletion) []ShellCompletion {
-	matchingNames := make([]string, 0, len((*flag).Names()))
-
-	for _, name := range (*flag).Names() {
-		withPrefix := ""
-		if len(name) == 1 {
-			withPrefix = "-" + name
-		} else {
-			withPrefix = "--" + name
-		}
-
-		if strings.HasPrefix(withPrefix, input) {
-			matchingNames = append(matchingNames, withPrefix)
-		}
-	}
-
-	usage := ""
-	if dgf, ok := (*flag).(cli.DocGenerationFlag); ok {
-		usage = dgf.GetUsage()
-	}
-
-	for _, name := range matchingNames {
-		result = append(result, NewShellCompletion(name, usage))
-	}
-
-	return result
-}
-
-func GetCompletions(completionStyle CompletionStyle, root *cli.Command, args []string) CompletionResult {
-	result := getAllPossibleCompletions(completionStyle, root, args)
-
-	// If the user has not put in a colon, filter out colon commands
-	if len(args) > 0 && !strings.Contains(args[len(args)-1], ":") {
-		// Nothing with anything after a colon. Create a single entry for groups with the same colon subset
-		foundNames := make([]string, 0, len(result.Completions))
-		filteredCompletions := make([]ShellCompletion, 0, len(result.Completions))
-
-		for _, completion := range result.Completions {
-			name := completion.Name
-			firstColonIndex := strings.Index(name, ":")
-			if firstColonIndex > -1 {
-				name = name[0:firstColonIndex]
-				completion.Name = name
-				completion.Usage = ""
-			}
-
-			if !slices.Contains(foundNames, name) {
-				foundNames = append(foundNames, name)
-				filteredCompletions = append(filteredCompletions, completion)
-			}
-		}
-
-		result.Completions = filteredCompletions
-	}
-
-	return result
-}
-
-func getAllPossibleCompletions(completionStyle CompletionStyle, root *cli.Command, args []string) CompletionResult {
-	builder := shellCompletionBuilder{completionStyle: completionStyle}
-	completions := make([]ShellCompletion, 0)
-	if len(args) == 0 {
-		for _, child := range root.Commands {
-			completions = builder.createFromCommand("", child, completions)
-		}
-		return CompletionResult{Completions: completions, Behavior: ShellCompletionBehaviorDefault}
-	}
-
-	current := args[len(args)-1]
-	preceding := args[0 : len(args)-1]
-	cmd := root
-	i := 0
-	for i < len(preceding) {
-		arg := preceding[i]
-
-		if isFlag(arg) {
-			flag := findFlag(cmd, arg)
-			if flag == nil {
-				i++
-			} else if docFlag, ok := (*flag).(cli.DocGenerationFlag); ok && docFlag.TakesValue() {
-				// All flags except for bool flags take values
-				i += 2
-			} else {
-				i++
-			}
-		} else {
-			child := findChild(cmd, arg)
-			if child != nil {
-				cmd = child
-			}
-			i++
-		}
-	}
-
-	// Check if the previous arg was a flag expecting a value
-	if len(preceding) > 0 {
-		prev := preceding[len(preceding)-1]
-		if isFlag(prev) {
-			flag := findFlag(cmd, prev)
-			if flag != nil {
-				if fb, ok := (*flag).(*cli.StringFlag); ok && fb.TakesFile {
-					return CompletionResult{Completions: completions, Behavior: ShellCompletionBehaviorFile}
-				} else if docFlag, ok := (*flag).(cli.DocGenerationFlag); ok && docFlag.TakesValue() {
-					return CompletionResult{Completions: completions, Behavior: ShellCompletionBehaviorNoComplete}
-				}
-			}
-		}
-	}
-
-	// Completing a flag name
-	if isFlag(current) {
-		for _, flag := range cmd.Flags {
-			completions = builder.createFromFlag(current, &flag, completions)
-		}
-	}
-
-	for _, child := range cmd.Commands {
-		if !child.Hidden {
-			completions = builder.createFromCommand(current, child, completions)
-		}
-	}
-
-	return CompletionResult{
-		Completions: completions,
-		Behavior:    ShellCompletionBehaviorDefault,
-	}
-}
-
-func ExecuteShellCompletion(ctx context.Context, cmd *cli.Command) error {
-	root := cmd.Root()
-	args := rebuildColonSeparatedArgs(root.Args().Slice()[1:])
-
-	var completionStyle CompletionStyle
-	if style, ok := os.LookupEnv("COMPLETION_STYLE"); ok {
-		switch style {
-		case "bash":
-			completionStyle = CompletionStyleBash
-		case "zsh":
-			completionStyle = CompletionStyleZsh
-		case "pwsh":
-			completionStyle = CompletionStylePowershell
-		case "fish":
-			completionStyle = CompletionStyleFish
-		default:
-			return cli.Exit("COMPLETION_STYLE must be set to 'bash', 'zsh', 'pwsh', or 'fish'", 1)
-		}
-	} else {
-		return cli.Exit("COMPLETION_STYLE must be set to 'bash', 'zsh', 'pwsh', 'fish'", 1)
-	}
-
-	result := GetCompletions(completionStyle, root, args)
-
-	for _, completion := range result.Completions {
-		name := completion.Name
-		if completionStyle == CompletionStyleZsh {
-			name = strings.ReplaceAll(name, ":", "\\:")
-		}
-		if completionStyle == CompletionStyleZsh && len(completion.Usage) > 0 {
-			_, _ = fmt.Fprintf(cmd.Writer, "%s:%s\n", name, completion.Usage)
-		} else if completionStyle == CompletionStyleFish && len(completion.Usage) > 0 {
-			_, _ = fmt.Fprintf(cmd.Writer, "%s\t%s\n", name, completion.Usage)
-		} else {
-			_, _ = fmt.Fprintf(cmd.Writer, "%s\n", name)
-		}
-	}
-	return cli.Exit("", int(result.Behavior))
-}
-
-// When CLI arguments are passed in, they are separated on word barriers.
-// Most commonly this is whitespace but in some cases that may also be colons.
-// We wish to allow arguments with colons. To handle this, we append/prepend colons to their neighboring
-// arguments.
-//
-// Example: `rebuildColonSeparatedArgs(["a", "b", ":", "c", "d"])` => `["a", "b:c", "d"]`
-func rebuildColonSeparatedArgs(args []string) []string {
-	if len(args) == 0 {
-		return args
-	}
-
-	result := []string{}
-	i := 0
-
-	for i < len(args) {
-		current := args[i]
-
-		// Keep joining while the next element is ":" or the current element ends with ":"
-		for i+1 < len(args) && (args[i+1] == ":" || strings.HasSuffix(current, ":")) {
-			if args[i+1] == ":" {
-				current += ":"
-				i++
-				// Check if there's a following element after the ":"
-				if i+1 < len(args) && args[i+1] != ":" {
-					current += args[i+1]
-					i++
-				}
-			} else {
-				break
-			}
-		}
-
-		result = append(result, current)
-		i++
-	}
-
-	return result
-}
diff --git a/internal/autocomplete/autocomplete_test.go b/internal/autocomplete/autocomplete_test.go
deleted file mode 100644
index 3e8aa33..0000000
--- a/internal/autocomplete/autocomplete_test.go
+++ /dev/null
@@ -1,393 +0,0 @@
-package autocomplete
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/urfave/cli/v3"
-)
-
-func TestGetCompletions_EmptyArgs(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{Name: "generate", Usage: "Generate SDK"},
-			{Name: "test", Usage: "Run tests"},
-			{Name: "build", Usage: "Build project"},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{})
-
-	assert.Equal(t, ShellCompletionBehaviorDefault, result.Behavior)
-	assert.Len(t, result.Completions, 3)
-	assert.Contains(t, result.Completions, ShellCompletion{Name: "generate", Usage: "Generate SDK"})
-	assert.Contains(t, result.Completions, ShellCompletion{Name: "test", Usage: "Run tests"})
-	assert.Contains(t, result.Completions, ShellCompletion{Name: "build", Usage: "Build project"})
-}
-
-func TestGetCompletions_SubcommandPrefix(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{Name: "generate", Usage: "Generate SDK"},
-			{Name: "test", Usage: "Run tests"},
-			{Name: "build", Usage: "Build project"},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"ge"})
-
-	assert.Equal(t, ShellCompletionBehaviorDefault, result.Behavior)
-	assert.Len(t, result.Completions, 1)
-	assert.Equal(t, "generate", result.Completions[0].Name)
-	assert.Equal(t, "Generate SDK", result.Completions[0].Usage)
-}
-
-func TestGetCompletions_HiddenCommand(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{Name: "visible", Usage: "Visible command"},
-			{Name: "hidden", Usage: "Hidden command", Hidden: true},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{""})
-
-	assert.Len(t, result.Completions, 1)
-	assert.Equal(t, "visible", result.Completions[0].Name)
-}
-
-func TestGetCompletions_NestedSubcommand(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{
-				Name:  "config",
-				Usage: "Configuration commands",
-				Commands: []*cli.Command{
-					{Name: "get", Usage: "Get config value"},
-					{Name: "set", Usage: "Set config value"},
-				},
-			},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"config", "s"})
-
-	assert.Equal(t, ShellCompletionBehaviorDefault, result.Behavior)
-	assert.Len(t, result.Completions, 1)
-	assert.Equal(t, "set", result.Completions[0].Name)
-	assert.Equal(t, "Set config value", result.Completions[0].Usage)
-}
-
-func TestGetCompletions_FlagCompletion(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{
-				Name:  "generate",
-				Usage: "Generate SDK",
-				Flags: []cli.Flag{
-					&cli.StringFlag{Name: "output", Aliases: []string{"o"}, Usage: "Output directory"},
-					&cli.BoolFlag{Name: "verbose", Aliases: []string{"v"}, Usage: "Verbose output"},
-					&cli.StringFlag{Name: "format", Usage: "Output format"},
-				},
-			},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"generate", "--o"})
-
-	assert.Equal(t, ShellCompletionBehaviorDefault, result.Behavior)
-	assert.Len(t, result.Completions, 1)
-	assert.Equal(t, "--output", result.Completions[0].Name)
-	assert.Equal(t, "Output directory", result.Completions[0].Usage)
-}
-
-func TestGetCompletions_ShortFlagCompletion(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{
-				Name:  "generate",
-				Usage: "Generate SDK",
-				Flags: []cli.Flag{
-					&cli.StringFlag{Name: "output", Aliases: []string{"o"}, Usage: "Output directory"},
-					&cli.BoolFlag{Name: "verbose", Aliases: []string{"v"}, Usage: "Verbose output"},
-				},
-			},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"generate", "-v"})
-
-	assert.Equal(t, ShellCompletionBehaviorDefault, result.Behavior)
-	assert.Len(t, result.Completions, 1)
-	assert.Equal(t, "-v", result.Completions[0].Name)
-}
-
-func TestGetCompletions_FileFlagBehavior(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{
-				Name:  "generate",
-				Usage: "Generate SDK",
-				Flags: []cli.Flag{
-					&cli.StringFlag{Name: "config", Aliases: []string{"c"}, Usage: "Config file", TakesFile: true},
-				},
-			},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"generate", "--config", ""})
-
-	assert.EqualValues(t, ShellCompletionBehaviorFile, result.Behavior)
-	assert.Empty(t, result.Completions)
-}
-
-func TestGetCompletions_NonBoolFlagValue(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{
-				Name:  "generate",
-				Usage: "Generate SDK",
-				Flags: []cli.Flag{
-					&cli.StringFlag{Name: "format", Usage: "Output format"},
-				},
-			},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"generate", "--format", ""})
-
-	assert.EqualValues(t, ShellCompletionBehaviorNoComplete, result.Behavior)
-	assert.Empty(t, result.Completions)
-}
-
-func TestGetCompletions_BoolFlagDoesNotBlockCompletion(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{
-				Name:  "generate",
-				Usage: "Generate SDK",
-				Flags: []cli.Flag{
-					&cli.BoolFlag{Name: "verbose", Aliases: []string{"v"}, Usage: "Verbose output"},
-				},
-				Commands: []*cli.Command{
-					{Name: "typescript", Usage: "Generate TypeScript SDK"},
-					{Name: "python", Usage: "Generate Python SDK"},
-				},
-			},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"generate", "--verbose", "ty"})
-
-	assert.Equal(t, ShellCompletionBehaviorDefault, result.Behavior)
-	assert.Len(t, result.Completions, 1)
-	assert.Equal(t, "typescript", result.Completions[0].Name)
-}
-
-func TestGetCompletions_ColonCommands_NoColonTyped(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{Name: "config:get", Usage: "Get config value"},
-			{Name: "config:set", Usage: "Set config value"},
-			{Name: "config:list", Usage: "List config values"},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"co"})
-
-	// Should collapse to single "config" entry without usage
-	assert.Len(t, result.Completions, 1)
-	assert.Equal(t, "config", result.Completions[0].Name)
-	assert.Equal(t, "", result.Completions[0].Usage)
-}
-
-func TestGetCompletions_ColonCommands_ColonTyped_Bash(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{Name: "config:get", Usage: "Get config value"},
-			{Name: "config:set", Usage: "Set config value"},
-			{Name: "config:list", Usage: "List config values"},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"config:"})
-
-	// For bash, should show suffixes only
-	assert.Len(t, result.Completions, 3)
-	names := []string{result.Completions[0].Name, result.Completions[1].Name, result.Completions[2].Name}
-	assert.Contains(t, names, "get")
-	assert.Contains(t, names, "set")
-	assert.Contains(t, names, "list")
-}
-
-func TestGetCompletions_ColonCommands_ColonTyped_Zsh(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{Name: "config:get", Usage: "Get config value"},
-			{Name: "config:set", Usage: "Set config value"},
-			{Name: "config:list", Usage: "List config values"},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleZsh, root, []string{"config:"})
-
-	// For zsh, should show full names
-	assert.Len(t, result.Completions, 3)
-	names := []string{result.Completions[0].Name, result.Completions[1].Name, result.Completions[2].Name}
-	assert.Contains(t, names, "config:get")
-	assert.Contains(t, names, "config:set")
-	assert.Contains(t, names, "config:list")
-}
-
-func TestGetCompletions_BashStyleColonCompletion(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{Name: "config:get", Usage: "Get config value"},
-			{Name: "config:set", Usage: "Set config value"},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"config:g"})
-
-	// For bash, should return suffix from after the colon in the input
-	// Input "config:g" has colon at index 6, so we take name[7:] from matched commands
-	assert.Len(t, result.Completions, 1)
-	assert.Equal(t, "get", result.Completions[0].Name)
-	assert.Equal(t, "Get config value", result.Completions[0].Usage)
-}
-
-func TestGetCompletions_BashStyleColonCompletion_NoMatch(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{Name: "config:get", Usage: "Get config value"},
-			{Name: "config:set", Usage: "Set config value"},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"other:g"})
-
-	// No matches
-	assert.Len(t, result.Completions, 0)
-}
-
-func TestGetCompletions_ZshStyleColonCompletion(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{Name: "config:get", Usage: "Get config value"},
-			{Name: "config:set", Usage: "Set config value"},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleZsh, root, []string{"config:g"})
-
-	// For zsh, should return full name
-	assert.Len(t, result.Completions, 1)
-	assert.Equal(t, "config:get", result.Completions[0].Name)
-	assert.Equal(t, "Get config value", result.Completions[0].Usage)
-}
-
-func TestGetCompletions_MixedColonAndRegularCommands(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{Name: "generate", Usage: "Generate SDK"},
-			{Name: "config:get", Usage: "Get config value"},
-			{Name: "config:set", Usage: "Set config value"},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{""})
-
-	// Should show "generate" and "config" (collapsed)
-	assert.Len(t, result.Completions, 2)
-	names := []string{result.Completions[0].Name, result.Completions[1].Name}
-	assert.Contains(t, names, "generate")
-	assert.Contains(t, names, "config")
-}
-
-func TestGetCompletions_FlagWithBoolFlagSkipsValue(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{
-				Name:  "generate",
-				Usage: "Generate SDK",
-				Flags: []cli.Flag{
-					&cli.BoolFlag{Name: "verbose", Aliases: []string{"v"}},
-					&cli.StringFlag{Name: "output", Aliases: []string{"o"}},
-				},
-				Commands: []*cli.Command{
-					{Name: "typescript", Usage: "TypeScript SDK"},
-				},
-			},
-		},
-	}
-
-	// Bool flag should not consume the next arg as a value
-	result := GetCompletions(CompletionStyleBash, root, []string{"generate", "-v", "ty"})
-
-	assert.Len(t, result.Completions, 1)
-	assert.Equal(t, "typescript", result.Completions[0].Name)
-}
-
-func TestGetCompletions_MultipleFlagsBeforeSubcommand(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{
-				Name:  "generate",
-				Usage: "Generate SDK",
-				Flags: []cli.Flag{
-					&cli.StringFlag{Name: "config", Aliases: []string{"c"}},
-					&cli.BoolFlag{Name: "verbose", Aliases: []string{"v"}},
-				},
-				Commands: []*cli.Command{
-					{Name: "typescript", Usage: "TypeScript SDK"},
-					{Name: "python", Usage: "Python SDK"},
-				},
-			},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"generate", "-c", "config.yml", "-v", "py"})
-
-	assert.Len(t, result.Completions, 1)
-	assert.Equal(t, "python", result.Completions[0].Name)
-}
-
-func TestGetCompletions_CommandAliases(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{Name: "generate", Aliases: []string{"gen", "g"}, Usage: "Generate SDK"},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"g"})
-
-	// Should match all aliases that start with "g"
-	assert.GreaterOrEqual(t, len(result.Completions), 2) // "generate" and "gen", possibly "g" too
-	names := []string{}
-	for _, c := range result.Completions {
-		names = append(names, c.Name)
-	}
-	assert.Contains(t, names, "generate")
-	assert.Contains(t, names, "gen")
-}
-
-func TestGetCompletions_AllFlagsWhenNoPrefix(t *testing.T) {
-	root := &cli.Command{
-		Commands: []*cli.Command{
-			{
-				Name:  "generate",
-				Usage: "Generate SDK",
-				Flags: []cli.Flag{
-					&cli.StringFlag{Name: "output", Aliases: []string{"o"}},
-					&cli.BoolFlag{Name: "verbose", Aliases: []string{"v"}},
-					&cli.StringFlag{Name: "format", Aliases: []string{"f"}},
-				},
-			},
-		},
-	}
-
-	result := GetCompletions(CompletionStyleBash, root, []string{"generate", "-"})
-
-	// Should show all flag variations
-	assert.GreaterOrEqual(t, len(result.Completions), 6) // -o, --output, -v, --verbose, -f, --format
-}
diff --git a/internal/autocomplete/shellscripts/bash_autocomplete.bash b/internal/autocomplete/shellscripts/bash_autocomplete.bash
deleted file mode 100755
index 8fb7b0b..0000000
--- a/internal/autocomplete/shellscripts/bash_autocomplete.bash
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/bin/bash
-
-____APPNAME___bash_autocomplete() {
-  if [[ "${COMP_WORDS[0]}" != "source" ]]; then
-    local cur completions exit_code
-    local IFS=$'\n'
-    cur="${COMP_WORDS[COMP_CWORD]}"
-
-    completions=$(COMPLETION_STYLE=bash "${COMP_WORDS[0]}" __complete -- "${COMP_WORDS[@]:1:$COMP_CWORD-1}" "$cur" 2>/dev/null)
-    exit_code=$?
-
-    local last_token="$cur"
-
-    # If the last token has been split apart by a ':', join it back together.
-    # Ex: 'a:b' will be represented in COMP_WORDS as 'a', ':', 'b'
-    if [[ $COMP_CWORD -ge 2 ]]; then
-      local prev2="${COMP_WORDS[COMP_CWORD - 2]}"
-      local prev1="${COMP_WORDS[COMP_CWORD - 1]}"
-      if [[ "$prev2" =~ ^@(file|data)$ && "$prev1" == ":" && "$cur" =~ ^// ]]; then
-        last_token="$prev2:$cur"
-      fi
-    fi
-
-    # Check for custom file completion patterns
-    local prefix=""
-    local file_part="$cur"
-    local force_file_completion=false
-    if [[ "$last_token" =~ (.*)@(file://|data://)?(.*)$ ]]; then
-      local before_at="${BASH_REMATCH[1]}"
-      local protocol="${BASH_REMATCH[2]}"
-      file_part="${BASH_REMATCH[3]}"
-
-      if [[ "$protocol" == "" ]]; then
-        prefix="$before_at@"
-      else
-        if [[ "$before_at" == "" ]]; then
-          prefix="//"
-        else
-          prefix="$before_at@$protocol"
-        fi
-      fi
-
-      force_file_completion=true
-    fi
-
-    if [[ "$force_file_completion" == true ]]; then
-      mapfile -t COMPREPLY < <(compgen -f -- "$file_part" | sed "s|^|$prefix|")
-    else
-      case $exit_code in
-      10) mapfile -t COMPREPLY < <(compgen -f -- "$cur") ;; # file completion
-      11) COMPREPLY=() ;;                                   # no completion
-      0) mapfile -t COMPREPLY <<<"$completions" ;;          # use returned completions
-      esac
-    fi
-    return 0
-  fi
-}
-
-complete -F ____APPNAME___bash_autocomplete __APPNAME__
diff --git a/internal/autocomplete/shellscripts/fish_autocomplete.fish b/internal/autocomplete/shellscripts/fish_autocomplete.fish
deleted file mode 100644
index b853057..0000000
--- a/internal/autocomplete/shellscripts/fish_autocomplete.fish
+++ /dev/null
@@ -1,51 +0,0 @@
-#!/usr/bin/env fish
-
-function ____APPNAME___fish_autocomplete
-    set -l tokens (commandline -xpc)
-    set -l current (commandline -ct)
-
-    set -l cmd $tokens[1]
-    set -l args $tokens[2..-1]
-
-    set -l completions (env COMPLETION_STYLE=fish $cmd __complete -- $args $current 2>>/tmp/fish-debug.log)
-    set -l exit_code $status
-
-    # Check for custom file completion patterns
-    # Patterns can appear anywhere in the word (e.g., inside quotes: 'my file is @file://path')
-    set -l prefix ""
-    set -l file_part "$current"
-    set -l force_file_completion 0
-
-    if string match -gqr '^(?<before>.*)@(?<protocol>file://|data://)?(?<file_part>.*)$' -- $current
-        if string match -qr '^[\'"]' -- $before
-            # Ensures we don't insert an extra quote when the user is building an argument in quotes
-            set before (string sub -s 2 -- $before)
-        end
-
-        set prefix "$before@$protocol"
-        set force_file_completion 1
-    end
-
-    if test $force_file_completion -eq 1
-        for path in (__fish_complete_path "$file_part")
-            echo $prefix$path
-        end
-    else
-        switch $exit_code
-            case 10
-                # File completion
-                __fish_complete_path "$current"
-            case 11
-                # No completion
-                return 0
-            case 0
-                # Use returned completions
-                for completion in $completions
-                    echo $completion
-                end
-        end
-    end
-end
-
-complete -c __APPNAME__ -f -a '(____APPNAME___fish_autocomplete)'
-
diff --git a/internal/autocomplete/shellscripts/pwsh_autocomplete.ps1 b/internal/autocomplete/shellscripts/pwsh_autocomplete.ps1
deleted file mode 100644
index 7cd6e62..0000000
--- a/internal/autocomplete/shellscripts/pwsh_autocomplete.ps1
+++ /dev/null
@@ -1,97 +0,0 @@
-Register-ArgumentCompleter -Native -CommandName __APPNAME__ -ScriptBlock {
-  param($wordToComplete, $commandAst, $cursorPosition)
-
-  $elements = $commandAst.CommandElements
-  $completionArgs = @()
-
-  # Extract each of the arguments
-  for ($i = 0; $i -lt $elements.Count; $i++) {
-    $completionArgs += $elements[$i].Extent.Text
-  }
-
-  # Add empty string if there's a trailing space (wordToComplete is empty but cursor is after space)
-  # Necessary for differentiating between getting completions for namespaced commands vs. subcommands
-  if ($wordToComplete.Length -eq 0 -and $elements.Count -gt 0) {
-    $completionArgs += ""
-  }
-
-  $output = & {
-    $env:COMPLETION_STYLE = 'pwsh'
-    __APPNAME__ __complete @completionArgs 2>&1
-  }
-  $exitCode = $LASTEXITCODE
-
-  # Check for custom file completion patterns
-  # Patterns can appear anywhere in the word (e.g., inside quotes: 'my file is @file://path')
-  $prefix = ""
-  $filePart = $wordToComplete
-  $forceFileCompletion = $false
-
-  # PowerShell includes quotes in $wordToComplete - strip them for pattern matching
-  # but preserve them in the prefix for the completion result
-  $wordContent = $wordToComplete
-  $leadingQuote = ""
-  if ($wordToComplete -match '^([''"])(.*)(\1)$') {
-    # Fully quoted: "content" or 'content'
-    $leadingQuote = $Matches[1]
-    $wordContent = $Matches[2]
-  } elseif ($wordToComplete -match '^([''"])(.*)$') {
-    # Opening quote only: "content or 'content
-    $leadingQuote = $Matches[1]
-    $wordContent = $Matches[2]
-  }
-
-  if ($wordContent -match '^(.*)@(file://|data://)?(.*)$') {
-    $prefix = $leadingQuote + $Matches[1] + '@' + $Matches[2]
-    $filePart = $Matches[3]
-    $forceFileCompletion = $true
-  }
-
-  if ($forceFileCompletion) {
-    # Handle empty filePart (e.g., "@" or "@file://") by listing current directory
-    $items = if ([string]::IsNullOrEmpty($filePart)) {
-      Get-ChildItem -ErrorAction SilentlyContinue
-    } else {
-      Get-ChildItem -Path "$filePart*" -ErrorAction SilentlyContinue
-    }
-    $items | ForEach-Object {
-      $completionText = if ($_.PSIsContainer) { $prefix + $_.Name + "/" } else { $prefix + $_.Name }
-      [System.Management.Automation.CompletionResult]::new(
-        $completionText,
-        $completionText,
-        'ProviderItem',
-        $completionText
-      )
-    }
-  } else {
-    switch ($exitCode) {
-      10 {
-        # File completion behavior
-        $items = if ([string]::IsNullOrEmpty($wordToComplete)) {
-          Get-ChildItem -ErrorAction SilentlyContinue
-        } else {
-          Get-ChildItem -Path "$wordToComplete*" -ErrorAction SilentlyContinue
-        }
-        $items | ForEach-Object {
-          $completionText = if ($_.PSIsContainer) { $_.Name + "/" } else { $_.Name }
-          [System.Management.Automation.CompletionResult]::new(
-            $completionText,
-            $completionText,
-            'ProviderItem',
-            $completionText
-          )
-        }
-      }
-      11 {
-        # No reasonable suggestions
-        [System.Management.Automation.CompletionResult]::new(' ', ' ', 'ParameterValue', ' ')
-      }
-      default {
-        # Default behavior - show command completions
-        $output | ForEach-Object {
-          [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
-        }
-      }
-    }
-  }
-}
diff --git a/internal/autocomplete/shellscripts/zsh_autocomplete.zsh b/internal/autocomplete/shellscripts/zsh_autocomplete.zsh
deleted file mode 100644
index 4d4bdcd..0000000
--- a/internal/autocomplete/shellscripts/zsh_autocomplete.zsh
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/bin/zsh
-compdef ____APPNAME___zsh_autocomplete __APPNAME__
-
-____APPNAME___zsh_autocomplete() {
-
-  local -a opts
-  local temp
-  local exit_code
-
-  temp=$(COMPLETION_STYLE=zsh "${words[1]}" __complete "${words[@]:1}")
-  exit_code=$?
-
-  # Check for custom file completion patterns
-  # Patterns can appear anywhere in the word (e.g., inside quotes: 'my file is @file://path')
-  local cur="${words[CURRENT]}"
-
-  if [[ "$cur" = *'@'* ]]; then
-    # Extract everything after the last @
-    local after_last_at="${cur##*@}"
-
-    if [[ $after_last_at =~ ^(file://|data://) ]]; then
-      compset -P "*$MATCH"
-      _files
-    else
-      compset -P '*@'
-      _files
-    fi
-    return
-  fi
-
-  case $exit_code in
-    10)
-      # File completion behavior
-      _files
-      ;;
-    11)
-      # No completion behavior - return nothing
-      return 1
-      ;;
-    0)
-      # Default behavior - show command completions
-      opts=("${(@f)temp}")
-      _describe 'values' opts
-      ;;
-  esac
-}
diff --git a/internal/binaryparam/binary_param.go b/internal/binaryparam/binary_param.go
deleted file mode 100644
index 40d4ecf..0000000
--- a/internal/binaryparam/binary_param.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package binaryparam
-
-import (
-	"io"
-	"os"
-)
-
-const stdinGlyph = "-"
-
-// FileOrStdin opens the file at the given path for reading. If the path is "-", stdin is returned instead.
-//
-// It's the caller's responsibility to close the returned ReadCloser (usually with `defer`).
-//
-// Returns a boolean indicating whether stdin is being used. If true, no other components of the calling
-// program should attempt to read from stdin for anything else.
-func FileOrStdin(stdin io.ReadCloser, path string) (io.ReadCloser, bool, error) {
-	// When the special glyph "-" is used, read from stdin. Although probably less necessary, also support
-	// special Unix files that refer to stdin.
-	switch path {
-	case "", stdinGlyph, "/dev/fd/0", "/dev/stdin":
-		return stdin, true, nil
-	}
-
-	readCloser, err := os.Open(path)
-	if err != nil {
-		return nil, false, err
-	}
-
-	return readCloser, false, err
-}
diff --git a/internal/binaryparam/binary_param_test.go b/internal/binaryparam/binary_param_test.go
deleted file mode 100644
index 7a66682..0000000
--- a/internal/binaryparam/binary_param_test.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package binaryparam
-
-import (
-	"io"
-	"os"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestFileOrStdin(t *testing.T) {
-	t.Parallel()
-
-	const expectedContents = "test file contents"
-
-	t.Run("WithFile", func(t *testing.T) {
-		tempFile := t.TempDir() + "/test_file.txt"
-		require.NoError(t, os.WriteFile(tempFile, []byte(expectedContents), 0600))
-
-		readCloser, stdinInUse, err := FileOrStdin(os.Stdin, tempFile)
-		require.NoError(t, err)
-		t.Cleanup(func() { require.NoError(t, readCloser.Close()) })
-
-		actualContents, err := io.ReadAll(readCloser)
-		require.NoError(t, err)
-		require.Equal(t, expectedContents, string(actualContents))
-
-		require.False(t, stdinInUse)
-	})
-
-	stdinTests := []struct {
-		testName string
-		path     string
-	}{
-		{"TestEmptyString", ""},
-		{"TestDash", "-"},
-		{"TestDevStdin", "/dev/stdin"},
-		{"TestDevFD0", "/dev/fd/0"},
-	}
-	for _, test := range stdinTests {
-		t.Run(test.testName, func(t *testing.T) {
-			tempFile := t.TempDir() + "/test_file.txt"
-			require.NoError(t, os.WriteFile(tempFile, []byte(expectedContents), 0600))
-
-			stubStdin, err := os.Open(tempFile)
-			require.NoError(t, err)
-			t.Cleanup(func() { require.NoError(t, stubStdin.Close()) })
-
-			readCloser, stdinInUse, err := FileOrStdin(stubStdin, test.path)
-			require.NoError(t, err)
-
-			actualContents, err := io.ReadAll(readCloser)
-			require.NoError(t, err)
-			require.Equal(t, expectedContents, string(actualContents))
-
-			require.True(t, stdinInUse)
-		})
-	}
-}
diff --git a/internal/debugmiddleware/debug_middleware.go b/internal/debugmiddleware/debug_middleware.go
deleted file mode 100644
index f07b93b..0000000
--- a/internal/debugmiddleware/debug_middleware.go
+++ /dev/null
@@ -1,127 +0,0 @@
-package debugmiddleware
-
-import (
-	"bytes"
-	"io"
-	"log"
-	"net/http"
-	"net/http/httputil"
-	"reflect"
-	"strings"
-)
-
-// For the time being these type definitions are duplicated here so that we can
-// test this file in a non-generated context.
-type (
-	Middleware     = func(*http.Request, MiddlewareNext) (*http.Response, error)
-	MiddlewareNext = func(*http.Request) (*http.Response, error)
-)
-
-const redactedPlaceholder = "<REDACTED>"
-
-// Headers known to contain sensitive information like an API key. Note that this exclude `Authorization`,
-// which is handled specially in `redactRequest` below.
-var sensitiveHeaders = []string{}
-
-// RequestLogger is a middleware that logs HTTP requests and responses.
-type RequestLogger struct {
-	logger           interface{ Printf(string, ...any) } // field for testability; usually log.Default()
-	sensitiveHeaders []string                            // field for testability; usually sensitiveHeaders
-}
-
-// NewRequestLogger returns a new RequestLogger instance with default options.
-func NewRequestLogger() *RequestLogger {
-	return &RequestLogger{
-		logger:           log.Default(),
-		sensitiveHeaders: sensitiveHeaders,
-	}
-}
-
-func (m *RequestLogger) Middleware() Middleware {
-	return func(req *http.Request, mn MiddlewareNext) (*http.Response, error) {
-		redacted, err := m.redactRequest(req)
-		if err != nil {
-			return nil, err
-		}
-		if reqBytes, err := httputil.DumpRequest(redacted, true); err == nil {
-			m.logger.Printf("Request Content:\n%s\n", reqBytes)
-		}
-
-		resp, err := mn(req)
-		if err != nil {
-			return resp, err
-		}
-
-		if respBytes, err := httputil.DumpResponse(resp, true); err == nil {
-			m.logger.Printf("Response Content:\n%s\n", respBytes)
-		}
-
-		return resp, err
-	}
-}
-
-// redactRequest redacts sensitive information from the request for logging
-// purposes. If redaction is necessary, the request is cloned before mutating
-// the original and that clone is returned. As a small optimization, the
-// original is request is returned unchanged if no redaction is necessary.
-func (m *RequestLogger) redactRequest(req *http.Request) (*http.Request, error) {
-	redactedHeaders := req.Header.Clone()
-
-	// Notably, the clauses below are written so they can redact multiple
-	// headers of the same name if necessary.
-	if values := redactedHeaders.Values("Authorization"); len(values) > 0 {
-		redactedHeaders.Del("Authorization")
-
-		for _, value := range values {
-			// In case we're using something like a bearer token (e.g. `Bearer
-			// <my_token>`), keep the `Bearer` part for more debugging
-			// information.
-			if authKind, _, ok := strings.Cut(value, " "); ok {
-				redactedHeaders.Add("Authorization", authKind+" "+redactedPlaceholder)
-			} else {
-				redactedHeaders.Add("Authorization", redactedPlaceholder)
-			}
-		}
-	}
-
-	for _, header := range m.sensitiveHeaders {
-		values := redactedHeaders.Values(header)
-		if len(values) == 0 {
-			continue
-		}
-
-		redactedHeaders.Del(header)
-
-		for range values {
-			redactedHeaders.Add(header, redactedPlaceholder)
-		}
-	}
-
-	if reflect.DeepEqual(req.Header, redactedHeaders) {
-		return req, nil
-	}
-
-	redacted := req.Clone(req.Context())
-	redacted.Header = redactedHeaders
-	var err error
-	redacted.Body, req.Body, err = cloneBody(req.Body)
-	return redacted, err
-}
-
-// This function returns two copies of an HTTP request body that can each be
-// read independently without affecting the other.
-// This logic is taken from `drainBody` in net/http/httputil.
-func cloneBody(b io.ReadCloser) (r1, r2 io.ReadCloser, err error) {
-	if b == nil || b == http.NoBody {
-		// No copying needed. Preserve the magic sentinel meaning of NoBody.
-		return http.NoBody, http.NoBody, nil
-	}
-	var buf bytes.Buffer
-	if _, err = buf.ReadFrom(b); err != nil {
-		return nil, b, err
-	}
-	if err = b.Close(); err != nil {
-		return nil, b, err
-	}
-	return io.NopCloser(&buf), io.NopCloser(bytes.NewReader(buf.Bytes())), nil
-}
diff --git a/internal/debugmiddleware/debug_middleware_test.go b/internal/debugmiddleware/debug_middleware_test.go
deleted file mode 100644
index 4e46fbc..0000000
--- a/internal/debugmiddleware/debug_middleware_test.go
+++ /dev/null
@@ -1,201 +0,0 @@
-package debugmiddleware
-
-import (
-	"bytes"
-	"io"
-	"log"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestDebugMiddleware(t *testing.T) {
-	t.Parallel()
-
-	setup := func() (*RequestLogger, *bytes.Buffer) {
-		var (
-			logBuf     bytes.Buffer
-			middleware = NewRequestLogger()
-		)
-		middleware.logger = log.New(&logBuf, "", 0)
-		return middleware, &logBuf
-	}
-
-	t.Run("DoesNotRedactMostHeaders", func(t *testing.T) {
-		t.Parallel()
-
-		middleware, logBuf := setup()
-
-		const stainlessUserAgent = "Stainless"
-
-		req := httptest.NewRequest("GET", "https://example.com", nil)
-		req.Header.Set("User-Agent", stainlessUserAgent)
-
-		var nextMiddlewareRan bool
-		middleware.Middleware()(req, func(req *http.Request) (*http.Response, error) {
-			nextMiddlewareRan = true
-
-			// The request sent down through middleware shouldn't be mutated.
-			require.Equal(t, stainlessUserAgent, req.Header.Get("User-Agent"))
-
-			return &http.Response{}, nil
-		})
-
-		require.True(t, nextMiddlewareRan)
-		require.Contains(t, logBuf.String(), "User-Agent: "+stainlessUserAgent)
-	})
-
-	const secretToken = "secret-token"
-
-	t.Run("RedactsAuthorizationHeader", func(t *testing.T) {
-		t.Parallel()
-
-		middleware, logBuf := setup()
-
-		req := httptest.NewRequest("GET", "https://example.com", nil)
-		req.Header.Set("Authorization", secretToken)
-
-		var nextMiddlewareRan bool
-		middleware.Middleware()(req, func(req *http.Request) (*http.Response, error) {
-			nextMiddlewareRan = true
-
-			// The request sent down through middleware shouldn't be mutated.
-			require.Equal(t, secretToken, req.Header.Get("Authorization"))
-
-			return &http.Response{}, nil
-		})
-
-		require.True(t, nextMiddlewareRan)
-		require.Contains(t, logBuf.String(), "Authorization: "+redactedPlaceholder)
-	})
-
-	t.Run("RedactsOnlySecretInAuthorizationHeader", func(t *testing.T) {
-		t.Parallel()
-
-		middleware, logBuf := setup()
-
-		req := httptest.NewRequest("GET", "https://example.com", nil)
-		req.Header.Set("Authorization", "Bearer "+secretToken)
-
-		var nextMiddlewareRan bool
-		middleware.Middleware()(req, func(req *http.Request) (*http.Response, error) {
-			nextMiddlewareRan = true
-
-			return &http.Response{}, nil
-		})
-
-		require.True(t, nextMiddlewareRan)
-		require.Contains(t, logBuf.String(), "Authorization: Bearer "+redactedPlaceholder)
-	})
-
-	t.Run("RedactsMultipleAuthorizationHeaders", func(t *testing.T) {
-		t.Parallel()
-
-		middleware, logBuf := setup()
-
-		req := httptest.NewRequest("GET", "https://example.com", nil)
-		req.Header.Add("Authorization", secretToken+"1")
-		req.Header.Add("Authorization", secretToken+"2")
-
-		var nextMiddlewareRan bool
-		middleware.Middleware()(req, func(req *http.Request) (*http.Response, error) {
-			nextMiddlewareRan = true
-
-			// The request sent down through middleware shouldn't be mutated.
-			require.Equal(t, []string{secretToken + "1", secretToken + "2"}, req.Header.Values("Authorization"))
-
-			return &http.Response{}, nil
-		})
-
-		require.True(t, nextMiddlewareRan)
-
-		if strings.Count(logBuf.String(), "Authorization: "+redactedPlaceholder) != 2 {
-			t.Error("expected exactly two redacted placeholders in authorization headers")
-		}
-	})
-
-	const customAPIKeyHeader = "X-My-Api-Key"
-
-	t.Run("RedactsSensitiveHeaders", func(t *testing.T) {
-		t.Parallel()
-
-		middleware, logBuf := setup()
-
-		middleware.sensitiveHeaders = []string{customAPIKeyHeader}
-
-		req := httptest.NewRequest("GET", "https://example.com", nil)
-		req.Header.Set(customAPIKeyHeader, secretToken)
-
-		var nextMiddlewareRan bool
-		middleware.Middleware()(req, func(req *http.Request) (*http.Response, error) {
-			nextMiddlewareRan = true
-
-			// The request sent down through middleware shouldn't be mutated.
-			require.Equal(t, secretToken, req.Header.Get(customAPIKeyHeader))
-
-			return &http.Response{}, nil
-		})
-
-		require.True(t, nextMiddlewareRan)
-		require.Contains(t, logBuf.String(), customAPIKeyHeader+": "+redactedPlaceholder)
-	})
-
-	t.Run("RedactsMultipleSensitiveHeaders", func(t *testing.T) {
-		t.Parallel()
-
-		middleware, logBuf := setup()
-
-		middleware.sensitiveHeaders = []string{customAPIKeyHeader}
-
-		req := httptest.NewRequest("GET", "https://example.com", nil)
-		req.Header.Add(customAPIKeyHeader, secretToken+"1")
-		req.Header.Add(customAPIKeyHeader, secretToken+"2")
-
-		var nextMiddlewareRan bool
-		middleware.Middleware()(req, func(req *http.Request) (*http.Response, error) {
-			nextMiddlewareRan = true
-
-			// The request sent down through middleware shouldn't be mutated.
-			require.Equal(t, []string{secretToken + "1", secretToken + "2"}, req.Header.Values(customAPIKeyHeader))
-
-			return &http.Response{}, nil
-		})
-
-		require.True(t, nextMiddlewareRan)
-		require.Equal(t, 2, strings.Count(logBuf.String(), customAPIKeyHeader+": "+redactedPlaceholder))
-	})
-
-	t.Run("DoesNotConsumeRequestBodyWhenIoReader", func(t *testing.T) {
-		t.Parallel()
-
-		middleware, logBuf := setup()
-		middleware.sensitiveHeaders = []string{customAPIKeyHeader}
-
-		const bodyContent = "test request body content"
-		bodyReader := strings.NewReader(bodyContent)
-
-		req := httptest.NewRequest("POST", "https://example.com", bodyReader)
-		req.Header.Set("Authorization", secretToken)
-
-		var nextMiddlewareRan bool
-		middleware.Middleware()(req, func(req *http.Request) (*http.Response, error) {
-			nextMiddlewareRan = true
-
-			// The request body should still be fully readable after the middleware runs
-			body, err := io.ReadAll(req.Body)
-			require.NoError(t, err)
-			require.Equal(t, bodyContent, string(body))
-
-			// The request sent down through middleware shouldn't be mutated.
-			require.Equal(t, secretToken, req.Header.Get("Authorization"))
-
-			return &http.Response{}, nil
-		})
-
-		require.True(t, nextMiddlewareRan)
-		require.Contains(t, logBuf.String(), "Authorization: "+redactedPlaceholder)
-	})
-}
diff --git a/internal/jsonview/explorer.go b/internal/jsonview/explorer.go
deleted file mode 100644
index 055541e..0000000
--- a/internal/jsonview/explorer.go
+++ /dev/null
@@ -1,775 +0,0 @@
-package jsonview
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"math"
-	"os"
-	"strings"
-
-	"github.com/charmbracelet/bubbles/help"
-	"github.com/charmbracelet/bubbles/key"
-	"github.com/charmbracelet/bubbles/table"
-	"github.com/charmbracelet/bubbles/viewport"
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-	"github.com/charmbracelet/x/term"
-	"github.com/muesli/reflow/truncate"
-	"github.com/muesli/reflow/wordwrap"
-	"github.com/tidwall/gjson"
-)
-
-const (
-	// UI layout constants
-	borderPadding     = 2
-	heightOffset      = 5
-	tableMinHeight    = 2
-	titlePaddingLeft  = 2
-	titlePaddingTop   = 0
-	footerPaddingLeft = 1
-
-	// Column width constants
-	defaultColumnWidth = 10
-	keyColumnWidth     = 3
-	valueColumnWidth   = 5
-
-	// String formatting constants
-	maxStringLength  = 100
-	maxPreviewLength = 24
-
-	arrayColor  = lipgloss.Color("1")
-	stringColor = lipgloss.Color("5")
-	objectColor = lipgloss.Color("4")
-)
-
-type keyMap struct {
-	Up         key.Binding
-	Down       key.Binding
-	Enter      key.Binding
-	Back       key.Binding
-	PrintValue key.Binding
-	Raw        key.Binding
-	Quit       key.Binding
-}
-
-func (k keyMap) ShortHelp() []key.Binding {
-	return []key.Binding{k.Quit, k.Up, k.Down, k.Back, k.Enter, k.PrintValue, k.Raw}
-}
-
-func (k keyMap) FullHelp() [][]key.Binding {
-	return [][]key.Binding{k.ShortHelp()}
-}
-
-var keys = keyMap{
-	Up: key.NewBinding(
-		key.WithKeys("up", "k"),
-		key.WithHelp("↑/k", "up"),
-	),
-	Down: key.NewBinding(
-		key.WithKeys("down", "j"),
-		key.WithHelp("↓/j", "down"),
-	),
-	Back: key.NewBinding(
-		key.WithKeys("left", "h", "backspace"),
-		key.WithHelp("←/h", "go back"),
-	),
-	Enter: key.NewBinding(
-		key.WithKeys("right", "l"),
-		key.WithHelp("→/l", "expand"),
-	),
-	PrintValue: key.NewBinding(
-		key.WithKeys("p"),
-		key.WithHelp("p", "print and exit"),
-	),
-	Raw: key.NewBinding(
-		key.WithKeys("r"),
-		key.WithHelp("r", "toggle raw JSON"),
-	),
-	Quit: key.NewBinding(
-		key.WithKeys("q", "esc", "ctrl+c", "enter"),
-		key.WithHelp("q/enter", "quit"),
-	),
-}
-
-var (
-	titleStyle         = lipgloss.NewStyle().Bold(true).PaddingLeft(titlePaddingLeft).PaddingTop(titlePaddingTop)
-	arrayStyle         = lipgloss.NewStyle().BorderStyle(lipgloss.RoundedBorder()).BorderForeground(arrayColor)
-	stringStyle        = lipgloss.NewStyle().BorderStyle(lipgloss.RoundedBorder()).BorderForeground(stringColor)
-	objectStyle        = lipgloss.NewStyle().BorderStyle(lipgloss.RoundedBorder()).BorderForeground(objectColor)
-	stringLiteralStyle = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("2"))
-)
-
-type JSONView interface {
-	GetPath() string
-	GetData() gjson.Result
-	Update(tea.Msg, bool) tea.Cmd
-	View() string
-	Resize(width, height int)
-}
-
-type TableView struct {
-	width     int
-	height    int
-	path      string
-	data      gjson.Result
-	table     table.Model
-	rowData   []gjson.Result
-	iterator  AnyIterator
-	isLoading bool
-	columns   []table.Column
-}
-
-func (tv *TableView) GetPath() string       { return tv.path }
-func (tv *TableView) GetData() gjson.Result { return tv.data }
-func (tv *TableView) View() string          { return tv.table.View() }
-
-func (tv *TableView) Update(msg tea.Msg, raw bool) tea.Cmd {
-	var cmd tea.Cmd
-	tv.table, cmd = tv.table.Update(msg)
-
-	// Check if we need to load more data
-	if tv.iterator != nil && !tv.isLoading && tv.data.IsArray() {
-		cursor := tv.table.Cursor()
-		totalRows := len(tv.table.Rows())
-
-		// Load more when we're at the last row
-		if cursor == totalRows-1 {
-			tv.isLoading = true
-			return tv.loadMoreData(raw)
-		}
-	}
-
-	return cmd
-}
-
-func (tv *TableView) loadMoreData(raw bool) tea.Cmd {
-	return func() tea.Msg {
-		if tv.iterator == nil {
-			return nil
-		}
-
-		if !tv.iterator.Next() {
-			tv.isLoading = false
-			return tv.iterator.Err()
-		}
-
-		obj := tv.iterator.Current()
-		var result gjson.Result
-		if jsonBytes, err := json.Marshal(obj); err != nil {
-			return err
-		} else {
-			result = gjson.ParseBytes(jsonBytes)
-		}
-
-		if !result.Exists() {
-			tv.isLoading = false
-			return nil
-		}
-
-		// Add the new item to our data
-		tv.rowData = append(tv.rowData, result)
-
-		// Add new row to the table
-		newRow := table.Row{formatValue(result, raw)}
-
-		// For array of objects, we need to format according to columns
-		if len(tv.columns) > 1 && result.IsObject() {
-			newRow = make(table.Row, len(tv.columns))
-			for i, col := range tv.columns {
-				newRow[i] = formatValue(result.Get(col.Title), raw)
-			}
-		}
-
-		rows := tv.table.Rows()
-		rows = append(rows, newRow)
-		tv.table.SetRows(rows)
-
-		// Resize columns to accommodate the new data
-		tv.Resize(tv.width, tv.height)
-
-		tv.isLoading = false
-		return nil
-	}
-}
-
-func (tv *TableView) Resize(width, height int) {
-	tv.width = width
-	tv.height = height
-	tv.updateColumnWidths(width)
-	tv.table.SetHeight(min(height-heightOffset, tableMinHeight+len(tv.table.Rows())))
-}
-
-func (tv *TableView) updateColumnWidths(width int) {
-	columns := tv.table.Columns()
-	widths := make([]int, len(columns))
-
-	// Calculate required widths from headers and content
-	for i, col := range columns {
-		widths[i] = lipgloss.Width(col.Title)
-	}
-
-	for _, row := range tv.table.Rows() {
-		for i, cell := range row {
-			if i < len(widths) {
-				widths[i] = max(widths[i], lipgloss.Width(cell))
-			}
-		}
-	}
-
-	totalWidth := sum(widths)
-	available := width - borderPadding*len(columns)
-
-	if totalWidth <= available {
-		for i, w := range widths {
-			columns[i].Width = w
-		}
-		return
-	}
-
-	fairShare := float64(available) / float64(len(columns))
-	shrinkable := 0.0
-
-	for _, w := range widths {
-		if float64(w) > fairShare {
-			shrinkable += float64(w) - fairShare
-		}
-	}
-
-	if shrinkable > 0 {
-		excess := float64(totalWidth - available)
-		for i, w := range widths {
-			if float64(w) > fairShare {
-				reduction := (float64(w) - fairShare) * (excess / shrinkable)
-				widths[i] = int(math.Round(float64(w) - reduction))
-			}
-		}
-	}
-
-	for i, w := range widths {
-		columns[i].Width = w
-	}
-
-	tv.table.SetColumns(columns)
-}
-
-type TextView struct {
-	path     string
-	data     gjson.Result
-	viewport viewport.Model
-	ready    bool
-}
-
-func (tv *TextView) GetPath() string       { return tv.path }
-func (tv *TextView) GetData() gjson.Result { return tv.data }
-func (tv *TextView) View() string          { return tv.viewport.View() }
-
-func (tv *TextView) Update(msg tea.Msg, raw bool) tea.Cmd {
-	var cmd tea.Cmd
-	tv.viewport, cmd = tv.viewport.Update(msg)
-	return cmd
-}
-
-func (tv *TextView) Resize(width, height int) {
-	h := height - heightOffset
-	if !tv.ready {
-		tv.viewport = viewport.New(width, h)
-		tv.viewport.SetContent(wordwrap.String(tv.data.String(), width))
-		tv.ready = true
-		return
-	}
-	tv.viewport.Width = width
-	tv.viewport.Height = h
-}
-
-type JSONViewer struct {
-	stack   []JSONView
-	root    string
-	width   int
-	height  int
-	rawMode bool
-	message string
-	help    help.Model
-}
-
-// ExploreJSON explores a single JSON value known ahead of time
-func ExploreJSON(title string, json gjson.Result) error {
-	view, err := newView("", json, false)
-	if err != nil {
-		return err
-	}
-
-	viewer := &JSONViewer{stack: []JSONView{view}, root: title, rawMode: false, help: help.New()}
-
-	_, err = tea.NewProgram(viewer).Run()
-	if viewer.message != "" {
-		_, msgErr := fmt.Println("\n" + viewer.message)
-		err = errors.Join(err, msgErr)
-	}
-	return err
-}
-
-// ExploreJSONStream explores JSON data loaded incrementally via an iterator
-func ExploreJSONStream[T any](title string, it Iterator[T]) error {
-	anyIt := genericToAnyIterator(it)
-
-	preloadCount := 20
-	if termHeight, _, err := term.GetSize(os.Stdout.Fd()); err == nil {
-		preloadCount = termHeight
-	}
-
-	items := make([]any, 0, preloadCount)
-	for i := 0; i < preloadCount && anyIt.Next(); i++ {
-		items = append(items, anyIt.Current())
-	}
-
-	if err := anyIt.Err(); err != nil {
-		return err
-	}
-
-	// Convert items to JSON array
-	jsonBytes, err := json.Marshal(items)
-	if err != nil {
-		return err
-	}
-	arrayJSON := gjson.ParseBytes(jsonBytes)
-	view, err := newTableView("", arrayJSON, false)
-	if err != nil {
-		return err
-	}
-
-	// Set iterator if there might be more data
-	if len(items) == preloadCount {
-		view.iterator = anyIt
-	}
-
-	viewer := &JSONViewer{stack: []JSONView{view}, root: title, rawMode: false, help: help.New()}
-	_, err = tea.NewProgram(viewer).Run()
-	if viewer.message != "" {
-		_, msgErr := fmt.Println("\n" + viewer.message)
-		err = errors.Join(err, msgErr)
-	}
-	return err
-}
-
-func (v *JSONViewer) current() JSONView { return v.stack[len(v.stack)-1] }
-func (v *JSONViewer) Init() tea.Cmd     { return nil }
-
-func (v *JSONViewer) resize(width, height int) {
-	v.width, v.height = width, height
-	v.help.Width = width
-	for i := range v.stack {
-		v.stack[i].Resize(width, height)
-	}
-}
-
-func (v *JSONViewer) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.WindowSizeMsg:
-		v.resize(msg.Width-borderPadding, msg.Height)
-		return v, nil
-	case tea.KeyMsg:
-		switch {
-		case key.Matches(msg, keys.Quit):
-			return v, tea.Quit
-		case key.Matches(msg, keys.Enter):
-			return v.navigateForward()
-		case key.Matches(msg, keys.Back):
-			return v.navigateBack()
-		case key.Matches(msg, keys.Raw):
-			return v.toggleRaw()
-		case key.Matches(msg, keys.PrintValue):
-			v.message = v.getSelectedContent()
-			return v, tea.Quit
-		}
-	}
-
-	return v, v.current().Update(msg, v.rawMode)
-}
-
-func (v *JSONViewer) getSelectedContent() string {
-	tableView, ok := v.current().(*TableView)
-	if !ok {
-		return v.current().GetData().Raw
-	}
-
-	selected := tableView.rowData[tableView.table.Cursor()]
-	if selected.Type == gjson.String {
-		return selected.String()
-	}
-	return selected.Raw
-}
-
-func (v *JSONViewer) navigateForward() (tea.Model, tea.Cmd) {
-	tableView, ok := v.current().(*TableView)
-	if !ok {
-		return v, nil
-	}
-
-	cursor := tableView.table.Cursor()
-	selected := tableView.rowData[cursor]
-	if !v.canNavigateInto(selected) {
-		return v, nil
-	}
-
-	path := v.buildNavigationPath(tableView, cursor)
-	forwardView, err := newView(path, selected, v.rawMode)
-	if err != nil {
-		return v, nil
-	}
-
-	v.stack = append(v.stack, forwardView)
-	v.resize(v.width, v.height)
-	return v, nil
-}
-
-func (v *JSONViewer) buildNavigationPath(tableView *TableView, cursor int) string {
-	if tableView.data.IsArray() {
-		return fmt.Sprintf("%s[%d]", tableView.path, cursor)
-	}
-	key := tableView.data.Get("@keys").Array()[cursor].Str
-	return fmt.Sprintf("%s[%s]", tableView.path, quoteString(key))
-}
-
-func quoteString(s string) string {
-	// Replace backslashes and quotes with escaped versions
-	s = strings.ReplaceAll(s, "\\", "\\\\")
-	s = strings.ReplaceAll(s, "\"", "\\\"")
-	return stringLiteralStyle.Render("\"" + s + "\"")
-}
-
-func (v *JSONViewer) canNavigateInto(data gjson.Result) bool {
-	switch {
-	case data.IsArray():
-		return len(data.Array()) > 0
-	case data.IsObject():
-		return len(data.Map()) > 0
-	case data.Type == gjson.String:
-		str := data.String()
-		return strings.Contains(str, "\n") || lipgloss.Width(str) >= maxStringLength
-	}
-	return false
-}
-
-func (v *JSONViewer) navigateBack() (tea.Model, tea.Cmd) {
-	if len(v.stack) > 1 {
-		v.stack = v.stack[:len(v.stack)-1]
-	}
-	return v, nil
-}
-
-func (v *JSONViewer) toggleRaw() (tea.Model, tea.Cmd) {
-	v.rawMode = !v.rawMode
-
-	for i, view := range v.stack {
-		viewWithRaw, err := newView(view.GetPath(), view.GetData(), v.rawMode)
-		if err != nil {
-			return v, tea.Printf("Error: %s", err)
-		}
-		if newTV, ok := viewWithRaw.(*TableView); ok {
-			if tv, ok := view.(*TableView); ok && tv.iterator != nil {
-				newTV.iterator = tv.iterator
-			}
-		}
-		v.stack[i] = viewWithRaw
-	}
-
-	v.resize(v.width, v.height)
-	return v, nil
-}
-
-func (v *JSONViewer) View() string {
-	view := v.current()
-	title := v.buildTitle(view)
-	content := titleStyle.Render(title)
-	style := v.getStyleForData(view.GetData())
-	content += "\n" + style.Render(view.View())
-	content += "\n" + v.help.View(keys)
-	return content
-}
-
-func (v *JSONViewer) buildTitle(view JSONView) string {
-	title := v.root
-	if len(view.GetPath()) > 0 {
-		title += " → " + view.GetPath()
-	}
-	if v.rawMode {
-		title += " (JSON)"
-	}
-	return title
-}
-
-func (v *JSONViewer) getStyleForData(data gjson.Result) lipgloss.Style {
-	switch {
-	case data.Type == gjson.String:
-		return stringStyle
-	case data.IsArray():
-		return arrayStyle
-	default:
-		return objectStyle
-	}
-}
-
-func newView(path string, data gjson.Result, raw bool) (JSONView, error) {
-	if data.Type == gjson.String {
-		return newTextView(path, data)
-	}
-	return newTableView(path, data, raw)
-}
-
-func newTextView(path string, data gjson.Result) (*TextView, error) {
-	if !data.Exists() || data.Type != gjson.String {
-		return nil, fmt.Errorf("invalid text JSON")
-	}
-	return &TextView{path: path, data: data}, nil
-}
-
-func newTableView(path string, data gjson.Result, raw bool) (*TableView, error) {
-	if !data.Exists() || data.Type != gjson.JSON {
-		return nil, fmt.Errorf("invalid table JSON")
-	}
-
-	switch {
-	case data.IsArray():
-		array := data.Array()
-		if isArrayOfObjects(array) {
-			return newArrayOfObjectsTableView(path, data, array, raw), nil
-		} else {
-			return newArrayTableView(path, data, array, raw), nil
-		}
-	case data.IsObject():
-		return newObjectTableView(path, data, raw), nil
-	default:
-		return nil, fmt.Errorf("unsupported JSON type")
-	}
-}
-
-func newArrayTableView(path string, data gjson.Result, array []gjson.Result, raw bool) *TableView {
-	columns := []table.Column{{Title: "Items", Width: defaultColumnWidth}}
-	rows := make([]table.Row, 0, len(array))
-	rowData := make([]gjson.Result, 0, len(array))
-
-	for _, item := range array {
-		rows = append(rows, table.Row{formatValue(item, raw)})
-		rowData = append(rowData, item)
-	}
-
-	t := createTable(columns, rows, arrayColor)
-	return &TableView{
-		path:    path,
-		data:    data,
-		table:   t,
-		rowData: rowData,
-		columns: columns,
-	}
-}
-
-func newArrayOfObjectsTableView(path string, data gjson.Result, array []gjson.Result, raw bool) *TableView {
-	// Collect unique keys
-	keySet := make(map[string]struct{})
-	var columns []table.Column
-
-	for _, item := range array {
-		for _, key := range item.Get("@keys").Array() {
-			if _, exists := keySet[key.Str]; !exists {
-				keySet[key.Str] = struct{}{}
-				title := key.Str
-				columns = append(columns, table.Column{Title: title, Width: defaultColumnWidth})
-			}
-		}
-	}
-
-	rows := make([]table.Row, 0, len(array))
-	rowData := make([]gjson.Result, 0, len(array))
-
-	for _, item := range array {
-		row := make(table.Row, len(columns))
-		for i, col := range columns {
-			row[i] = formatValue(item.Get(col.Title), raw)
-		}
-		rows = append(rows, row)
-		rowData = append(rowData, item)
-	}
-
-	t := createTable(columns, rows, arrayColor)
-	return &TableView{
-		path:    path,
-		data:    data,
-		table:   t,
-		rowData: rowData,
-		columns: columns,
-	}
-}
-
-func newObjectTableView(path string, data gjson.Result, raw bool) *TableView {
-	columns := []table.Column{{Title: "Object"}, {}}
-
-	keys := data.Get("@keys").Array()
-	rows := make([]table.Row, 0, len(keys))
-	rowData := make([]gjson.Result, 0, len(keys))
-
-	for _, key := range keys {
-		value := data.Get(key.Str)
-		title := key.Str
-		rows = append(rows, table.Row{title, formatValue(value, raw)})
-		rowData = append(rowData, value)
-	}
-
-	// Adjust column widths based on content
-	for _, row := range rows {
-		for i, cell := range row {
-			if i < len(columns) {
-				columns[i].Width = max(columns[i].Width, lipgloss.Width(cell))
-			}
-		}
-	}
-
-	t := createTable(columns, rows, objectColor)
-	return &TableView{
-		path:    path,
-		data:    data,
-		table:   t,
-		rowData: rowData,
-		columns: columns,
-	}
-}
-
-func createTable(columns []table.Column, rows []table.Row, bgColor lipgloss.Color) table.Model {
-	t := table.New(
-		table.WithColumns(columns),
-		table.WithRows(rows),
-		table.WithFocused(true),
-	)
-
-	// Set common table styles
-	s := table.DefaultStyles()
-	s.Header = s.Header.
-		BorderStyle(lipgloss.NormalBorder()).
-		BorderForeground(lipgloss.Color("240")).
-		BorderBottom(true).
-		Bold(true)
-	s.Selected = s.Selected.
-		Foreground(lipgloss.Color("229")).
-		Background(bgColor).
-		Bold(false)
-	t.SetStyles(s)
-
-	return t
-}
-
-func formatValue(value gjson.Result, raw bool) string {
-	if raw {
-		return value.Get("@ugly").Raw
-	}
-
-	switch {
-	case value.IsObject():
-		return formatObject(value)
-	case value.IsArray():
-		return formatArray(value)
-	case value.Type == gjson.String:
-		return value.Str
-	default:
-		return value.Raw
-	}
-}
-
-func formatObject(value gjson.Result) string {
-	keys := value.Get("@keys").Array()
-	keyStrs := make([]string, len(keys))
-
-	for i, key := range keys {
-		val := value.Get(key.Str)
-		keyStrs[i] = formatObjectKey(key.Str, val)
-	}
-
-	return "{" + strings.Join(keyStrs, ", ") + "}"
-}
-
-func formatObjectKey(key string, val gjson.Result) string {
-	switch {
-	case val.IsObject():
-		return key + ":{…}"
-	case val.IsArray():
-		return key + ":[…]"
-	case val.Type == gjson.String:
-		str := val.Str
-		if lipgloss.Width(str) <= maxPreviewLength {
-			return fmt.Sprintf(`%s:"%s"`, key, str)
-		}
-		return fmt.Sprintf(`%s:"%s…"`, key, truncate.String(str, uint(maxPreviewLength)))
-	default:
-		return key + ":" + val.Raw
-	}
-}
-
-func formatArray(value gjson.Result) string {
-	switch count := len(value.Array()); count {
-	case 0:
-		return "[]"
-	case 1:
-		return "[...1 item...]"
-	default:
-		return fmt.Sprintf("[...%d items...]", count)
-	}
-}
-
-func isArrayOfObjects(array []gjson.Result) bool {
-	for _, item := range array {
-		if !item.IsObject() {
-			return false
-		}
-	}
-	return len(array) > 0
-}
-
-func sum(ints []int) int {
-	total := 0
-	for _, n := range ints {
-		total += n
-	}
-	return total
-}
-
-// An iterator over `any` values
-type AnyIterator interface {
-	Next() bool
-	Err() error
-	Current() any
-}
-
-// A generic iterator interface that is used by the `genericIterator` struct
-// below to convert iterators over specific types to an AnyIterator
-type Iterator[T any] interface {
-	Next() bool
-	Err() error
-	Current() T
-}
-
-// genericIterator adapts a generic Iterator[T] to an AnyIterator.
-type genericIterator[T any] struct {
-	iterator Iterator[T]
-	current  any
-}
-
-func (g *genericIterator[T]) Next() bool {
-	if !g.iterator.Next() {
-		return false
-	}
-	g.current = g.iterator.Current()
-	return true
-}
-
-func (g *genericIterator[T]) Err() error {
-	return g.iterator.Err()
-}
-
-func (g *genericIterator[T]) Current() any {
-	return g.current
-}
-
-func genericToAnyIterator[T any](it Iterator[T]) AnyIterator {
-	return &genericIterator[T]{
-		iterator: it,
-	}
-}
diff --git a/internal/jsonview/staticdisplay.go b/internal/jsonview/staticdisplay.go
deleted file mode 100644
index 768ea34..0000000
--- a/internal/jsonview/staticdisplay.go
+++ /dev/null
@@ -1,135 +0,0 @@
-package jsonview
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/charmbracelet/lipgloss"
-	"github.com/charmbracelet/x/term"
-	"github.com/muesli/reflow/truncate"
-	"github.com/tidwall/gjson"
-)
-
-const (
-	tabWidth = 2
-)
-
-var (
-	keyStyle         = lipgloss.NewStyle().Foreground(lipgloss.Color("75")).Bold(false)
-	stringValueStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("113"))
-	numberValueStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("215"))
-	boolValueStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("207"))
-	nullValueStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("245")).Italic(true)
-	bulletStyle      = lipgloss.NewStyle().Foreground(lipgloss.Color("242"))
-	containerStyle   = lipgloss.NewStyle().
-				Border(lipgloss.RoundedBorder()).
-				BorderForeground(lipgloss.Color("63")).
-				Padding(0, 1)
-)
-
-func formatJSON(json gjson.Result, width int) string {
-	if !json.Exists() {
-		return nullValueStyle.Render("Invalid JSON")
-	}
-	return formatResult(json, 0, width)
-}
-
-func formatResult(result gjson.Result, indent, width int) string {
-	switch result.Type {
-	case gjson.String:
-		str := result.Str
-		if str == "" {
-			return nullValueStyle.Render("(empty)")
-		}
-		if lipgloss.Width(str) > width {
-			str = truncate.String(str, uint(width-1)) + "…"
-		}
-		return stringValueStyle.Render(str)
-	case gjson.Number:
-		return numberValueStyle.Render(result.Raw)
-	case gjson.True:
-		return boolValueStyle.Render("yes")
-	case gjson.False:
-		return boolValueStyle.Render("no")
-	case gjson.Null:
-		return nullValueStyle.Render("null")
-	case gjson.JSON:
-		if result.IsArray() {
-			return formatJSONArray(result, indent, width)
-		}
-		return formatJSONObject(result, indent, width)
-	default:
-		return stringValueStyle.Render(result.String())
-	}
-}
-
-func isSingleLine(result gjson.Result, indent int) bool {
-	return !(result.IsObject() || result.IsArray())
-}
-
-func formatJSONArray(result gjson.Result, indent, width int) string {
-	items := result.Array()
-	if len(items) == 0 {
-		return nullValueStyle.Render(" (none)")
-	}
-
-	numberWidth := lipgloss.Width(fmt.Sprintf("%d. ", len(items)))
-
-	var formattedItems []string
-	for i, item := range items {
-		number := fmt.Sprintf("%d.", i+1)
-		numbering := getIndent(indent) + bulletStyle.Render(number)
-
-		// If the item will be a one-liner, put it inline after the numbering,
-		// otherwise it starts with a newline and goes below the numbering.
-		itemWidth := width
-		if isSingleLine(item, indent+1) {
-			// Add right-padding:
-			numbering += strings.Repeat(" ", numberWidth-lipgloss.Width(number))
-			itemWidth = width - lipgloss.Width(numbering)
-		}
-		value := formatResult(item, indent+1, itemWidth)
-		formattedItems = append(formattedItems, numbering+value)
-	}
-	return "\n" + strings.Join(formattedItems, "\n")
-}
-
-func formatJSONObject(result gjson.Result, indent, width int) string {
-	keys := result.Get("@keys").Array()
-	if len(keys) == 0 {
-		return nullValueStyle.Render("(empty)")
-	}
-
-	var items []string
-	for _, key := range keys {
-		value := result.Get(key.String())
-		keyStr := getIndent(indent) + keyStyle.Render(key.String()+":")
-		// If item will be a one-liner, put it inline after the key, otherwise
-		// it starts with a newline and goes below the key.
-		itemWidth := width
-		if isSingleLine(value, indent+1) {
-			keyStr += " "
-			itemWidth = width - lipgloss.Width(keyStr)
-		}
-		formattedValue := formatResult(value, indent+1, itemWidth)
-		items = append(items, keyStr+formattedValue)
-	}
-
-	return "\n" + strings.Join(items, "\n")
-}
-
-func getIndent(indent int) string {
-	return strings.Repeat(" ", indent*tabWidth)
-}
-
-func RenderJSON(title string, json gjson.Result) string {
-	width, _, err := term.GetSize(os.Stdout.Fd())
-	if err != nil {
-		width = 80
-	}
-	width -= containerStyle.GetBorderLeftSize() + containerStyle.GetBorderRightSize() +
-		containerStyle.GetPaddingLeft() + containerStyle.GetPaddingRight()
-	content := strings.TrimLeft(formatJSON(json, width), "\n")
-	return titleStyle.Render(title) + "\n" + containerStyle.Render(content)
-}
diff --git a/internal/mocktest/mocktest.go b/internal/mocktest/mocktest.go
deleted file mode 100644
index e51ceb5..0000000
--- a/internal/mocktest/mocktest.go
+++ /dev/null
@@ -1,101 +0,0 @@
-package mocktest
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"net"
-	"net/http"
-	"net/url"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-var mockServerURL *url.URL
-
-func init() {
-	mockServerURL, _ = url.Parse("http://localhost:4010")
-	if testURL := os.Getenv("TEST_API_BASE_URL"); testURL != "" {
-		if parsed, err := url.Parse(testURL); err == nil {
-			mockServerURL = parsed
-		}
-	}
-}
-
-// OnlyMockServerDialer only allows network connections to the mock server
-type OnlyMockServerDialer struct{}
-
-func (d *OnlyMockServerDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
-	if address == mockServerURL.Host {
-		return (&net.Dialer{}).DialContext(ctx, network, address)
-	}
-
-	return nil, fmt.Errorf("BLOCKED: connection to %s not allowed (only allowed: %s)", address, mockServerURL.Host)
-}
-
-func blockNetworkExceptMockServer() (http.RoundTripper, http.RoundTripper) {
-	restricted := &http.Transport{
-		DialContext: (&OnlyMockServerDialer{}).DialContext,
-	}
-
-	origClient, origDefault := http.DefaultClient.Transport, http.DefaultTransport
-	http.DefaultClient.Transport, http.DefaultTransport = restricted, restricted
-	return origClient, origDefault
-}
-
-func restoreNetwork(origClient, origDefault http.RoundTripper) {
-	http.DefaultClient.Transport, http.DefaultTransport = origClient, origDefault
-}
-
-// TestRunMockTestWithFlags runs a test against a mock server with the provided
-// CLI args and ensures it succeeds
-func TestRunMockTestWithFlags(t *testing.T, args ...string) {
-	TestRunMockTestWithPipeAndFlags(t, nil, args...)
-}
-
-// TestRunMockTestWithPipeAndFlags runs a test against a mock server with the provided
-// data piped over stdin and CLI args and ensures it succeeds
-func TestRunMockTestWithPipeAndFlags(t *testing.T, pipeData []byte, args ...string) {
-	origClient, origDefault := blockNetworkExceptMockServer()
-	defer restoreNetwork(origClient, origDefault)
-
-	// Check if mock server is running
-	conn, err := net.DialTimeout("tcp", mockServerURL.Host, 2*time.Second)
-	if err != nil {
-		require.Fail(t, "Mock server is not running on "+mockServerURL.Host+". Please start the mock server before running tests.")
-	} else {
-		conn.Close()
-	}
-
-	// Get the path to the main command
-	_, filename, _, ok := runtime.Caller(0)
-	require.True(t, ok, "Could not get current file path")
-	dirPath := filepath.Dir(filename)
-	project := filepath.Join(dirPath, "..", "..", "cmd", "beeper-desktop-cli")
-
-	args = append([]string{"run", project, "--base-url", mockServerURL.String()}, args...)
-
-	t.Logf("Testing command: go run ./cmd/beeper-desktop-cli %s", strings.Join(args[2:], " "))
-
-	cmd := exec.Command("go", args...)
-	cmd.Stdin = bytes.NewReader(pipeData)
-	output, err := cmd.CombinedOutput()
-	assert.NoError(t, err, "Test failed\nError: %v\nOutput: %s", err, output)
-
-	t.Logf("Test passed successfully\nOutput:\n%s", string(output))
-}
-
-func TestFile(t *testing.T, contents string) string {
-	tmpDir := t.TempDir()
-	filename := filepath.Join(tmpDir, "file.txt")
-	require.NoError(t, os.WriteFile(filename, []byte(contents), 0644))
-	return filename
-}
diff --git a/internal/requestflag/innerflag.go b/internal/requestflag/innerflag.go
deleted file mode 100644
index 102624f..0000000
--- a/internal/requestflag/innerflag.go
+++ /dev/null
@@ -1,260 +0,0 @@
-package requestflag
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-
-	"github.com/urfave/cli/v3"
-)
-
-// InnerFlag[T] represents a CLI flag for the urfave/cli package that allows setting
-// nested fields within other flags. For example, using `--foo.baz` will set the "baz"
-// field on a parent flag named `--foo`.
-type InnerFlag[
-	T []any | []map[string]any | []DateTimeValue | []DateValue | []TimeValue | []string |
-		[]float64 | []int64 | []bool | any | map[string]any | DateTimeValue | DateValue | TimeValue |
-		string | float64 | int64 | bool,
-] struct {
-	Name        string        // name of the flag
-	DefaultText string        // default text of the flag for usage purposes
-	Usage       string        // usage string for help output
-	Aliases     []string      // aliases that are allowed for this flag
-	Validator   func(T) error // custom function to validate this flag value
-
-	OuterFlag  cli.Flag // The flag on which this inner flag will set values
-	InnerField string   // The inner field which this flag will set
-}
-
-type HasOuterFlag interface {
-	cli.Flag
-	SetOuterFlag(cli.Flag)
-	GetOuterFlag() cli.Flag
-}
-
-func (f *InnerFlag[T]) SetOuterFlag(flag cli.Flag) {
-	f.OuterFlag = flag
-}
-
-func (f *InnerFlag[T]) GetOuterFlag() cli.Flag {
-	return f.OuterFlag
-}
-
-// Implementation of the cli.Flag interface
-var _ cli.Flag = (*InnerFlag[any])(nil) // Type assertion to ensure interface compliance
-
-func (f *InnerFlag[T]) PreParse() error {
-	return nil
-}
-
-func (f *InnerFlag[T]) PostParse() error {
-	return nil
-}
-
-func (f *InnerFlag[T]) Set(name string, rawVal string) error {
-	if parsedValue, err := parseCLIArg[T](rawVal); err != nil {
-		return err
-	} else {
-		if f.Validator != nil {
-			if err := f.Validator(parsedValue); err != nil {
-				return err
-			}
-		}
-
-		if settableInnerField, ok := f.OuterFlag.(SettableInnerField); ok {
-			settableInnerField.SetInnerField(f.InnerField, parsedValue)
-		} else {
-			return fmt.Errorf("Cannot set inner field on %v", f.OuterFlag)
-		}
-		return nil
-	}
-}
-
-func (f *InnerFlag[T]) Get() any {
-	var zeroValue T
-	return zeroValue
-}
-
-func (f *InnerFlag[T]) String() string {
-	return cli.FlagStringer(f)
-}
-
-func (f *InnerFlag[T]) IsSet() bool {
-	return false
-}
-
-func (f *InnerFlag[T]) Names() []string {
-	return cli.FlagNames(f.Name, f.Aliases)
-}
-
-// Implementation for the cli.DocGenerationFlag interface
-var _ cli.DocGenerationFlag = (*InnerFlag[any])(nil) // Type assertion to ensure interface compliance
-
-func (f *InnerFlag[T]) TakesValue() bool {
-	var t T
-	return reflect.TypeOf(t) == nil || reflect.TypeOf(t).Kind() != reflect.Bool
-}
-
-func (f *InnerFlag[T]) GetUsage() string {
-	return f.Usage
-}
-
-func (f *InnerFlag[T]) GetValue() string {
-	return ""
-}
-
-func (f *InnerFlag[T]) GetDefaultText() string {
-	return f.DefaultText
-}
-
-func (f *InnerFlag[T]) GetEnvVars() []string {
-	return nil
-}
-
-func (f *InnerFlag[T]) IsDefaultVisible() bool {
-	return false
-}
-
-func (f *InnerFlag[T]) TypeName() string {
-	var zeroValue T
-	ty := reflect.TypeOf(zeroValue)
-	if ty == nil {
-		return ""
-	}
-
-	// Get base type name with special handling for built-in types
-	getTypeName := func(t reflect.Type) string {
-		switch t.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			return "int"
-		case reflect.Float32, reflect.Float64:
-			return "float"
-		case reflect.Bool:
-			return "boolean"
-		case reflect.String:
-			switch t.Name() {
-			case "DateTimeValue":
-				return "datetime"
-			case "DateValue":
-				return "date"
-			case "TimeValue":
-				return "time"
-			default:
-				return "string"
-			}
-		default:
-			if t.Name() == "" {
-				return "any"
-			}
-			return strings.ToLower(t.Name())
-		}
-	}
-
-	switch ty.Kind() {
-	case reflect.Slice:
-		elemType := ty.Elem()
-		return getTypeName(elemType)
-	case reflect.Map:
-		keyType := ty.Key()
-		valueType := ty.Elem()
-		return fmt.Sprintf("%s=%s", getTypeName(keyType), getTypeName(valueType))
-	default:
-		return getTypeName(ty)
-	}
-}
-
-// Implementation for the cli.DocGenerationMultiValueFlag interface
-var _ cli.DocGenerationMultiValueFlag = (*InnerFlag[any])(nil) // Type assertion to ensure interface compliance
-
-func (f *InnerFlag[T]) IsMultiValueFlag() bool {
-	return false
-}
-
-func (f *InnerFlag[T]) IsBoolFlag() bool {
-	var zeroValue T
-	_, isBool := any(zeroValue).(bool)
-	return isBool
-}
-
-// WithInnerFlags takes a command and a map of flag names to inner flags,
-// and returns a modified command with the appropriate inner flags set.
-func WithInnerFlags(cmd cli.Command, innerFlagMap map[string][]HasOuterFlag) cli.Command {
-	if len(innerFlagMap) == 0 {
-		return cmd
-	}
-
-	// If any keys are unused by the end, we know that they were not valid
-	unusedInnerFlagKeys := make(map[string]struct{})
-	for name := range innerFlagMap {
-		unusedInnerFlagKeys[name] = struct{}{}
-	}
-
-	updatedFlags := make([]cli.Flag, 0, len(cmd.Flags))
-	for _, flag := range cmd.Flags {
-		updatedFlags = append(updatedFlags, flag)
-		for _, name := range flag.Names() {
-			// Check if this flag has inner flags in our map
-			innerFlags, hasInnerFlags := innerFlagMap[name]
-			if !hasInnerFlags {
-				continue
-			}
-
-			// Mark this inner flag key as used
-			delete(unusedInnerFlagKeys, name)
-
-			for _, innerFlag := range innerFlags {
-				innerFlag.SetOuterFlag(flag)
-				updatedFlags = append(updatedFlags, innerFlag)
-			}
-		}
-	}
-
-	// If there are inner flags that don't correspond to any valid outer flag
-	// names, then panic because the user probably made a typo or forgot to
-	// delete inner flags that correspond to missing outer flags.
-	if len(unusedInnerFlagKeys) > 0 {
-		unusedKeys := make([]string, 0, len(unusedInnerFlagKeys))
-		for key := range unusedInnerFlagKeys {
-			unusedKeys = append(unusedKeys, key)
-		}
-		panic(fmt.Sprintf("Missing outer flags to use with inner flags: %v", unusedKeys))
-	}
-
-	result := cmd
-	result.Flags = updatedFlags
-	return result
-}
-
-// Helper function to verify that all inner flags have an outer flag set and
-// follow the --foo.baz prefix format
-func CheckInnerFlags(cmd cli.Command) error {
-	var errors []string
-	for _, flag := range cmd.Flags {
-		if innerFlag, ok := flag.(HasOuterFlag); ok {
-			outerFlag := innerFlag.GetOuterFlag()
-			if outerFlag == nil {
-				errors = append(errors, fmt.Sprintf("inner flag %s is missing an outer flag", flag.Names()))
-				continue
-			}
-
-			innerFlagName := flag.Names()[0]
-			valid := false
-			for _, outerName := range outerFlag.Names() {
-				if strings.HasPrefix(innerFlagName, outerName+".") {
-					valid = true
-					break
-				}
-			}
-
-			if !valid {
-				errors = append(errors, fmt.Sprintf("inner flag %s must start with one of its outer flag's names followed by a dot", innerFlagName))
-			}
-		}
-	}
-
-	if len(errors) > 0 {
-		return fmt.Errorf("%s", strings.Join(errors, "; "))
-	}
-	return nil
-}
diff --git a/internal/requestflag/innerflag_test.go b/internal/requestflag/innerflag_test.go
deleted file mode 100644
index 3f204c9..0000000
--- a/internal/requestflag/innerflag_test.go
+++ /dev/null
@@ -1,319 +0,0 @@
-package requestflag
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/urfave/cli/v3"
-)
-
-func TestInnerFlagSet(t *testing.T) {
-	tests := []struct {
-		name      string
-		flagType  string
-		inputVal  string
-		expected  any
-		expectErr bool
-	}{
-		{"string", "string", "hello", "hello", false},
-		{"int64", "int64", "42", int64(42), false},
-		{"float64", "float64", "3.14", float64(3.14), false},
-		{"bool", "bool", "true", true, false},
-		{"invalid int", "int64", "not-a-number", nil, true},
-		{"invalid float", "float64", "not-a-float", nil, true},
-		{"invalid bool", "bool", "not-a-bool", nil, true},
-		{"yaml map", "map", "key: value", map[string]any{"key": "value"}, false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			outerFlag := &Flag[map[string]any]{
-				Name: "test-flag",
-			}
-
-			var innerFlag cli.Flag
-			switch tt.flagType {
-			case "string":
-				innerFlag = &InnerFlag[string]{
-					Name:       "test-flag.test-field",
-					OuterFlag:  outerFlag,
-					InnerField: "test_field",
-				}
-			case "int64":
-				innerFlag = &InnerFlag[int64]{
-					Name:       "test-flag.test-field",
-					OuterFlag:  outerFlag,
-					InnerField: "test_field",
-				}
-			case "float64":
-				innerFlag = &InnerFlag[float64]{
-					Name:       "test-flag.test-field",
-					OuterFlag:  outerFlag,
-					InnerField: "test_field",
-				}
-			case "bool":
-				innerFlag = &InnerFlag[bool]{
-					Name:       "test-flag.test-field",
-					OuterFlag:  outerFlag,
-					InnerField: "test_field",
-				}
-			case "map":
-				innerFlag = &InnerFlag[map[string]any]{
-					Name:       "test-flag.test-field",
-					OuterFlag:  outerFlag,
-					InnerField: "test_field",
-				}
-			}
-
-			err := innerFlag.Set(innerFlag.Names()[0], tt.inputVal)
-
-			if tt.expectErr {
-				assert.Error(t, err)
-				return
-			}
-
-			assert.NoError(t, err)
-			actual, ok := outerFlag.Get().(map[string]any)["test_field"]
-			assert.True(t, ok, "Field 'test_field' should exist in the map")
-			assert.Equal(t, tt.expected, actual, "Expected %v (%T), got %v (%T)", tt.expected, tt.expected, actual, actual)
-		})
-	}
-}
-
-func TestInnerFlagValidator(t *testing.T) {
-	outerFlag := &Flag[map[string]any]{Name: "test-flag"}
-
-	innerFlag := &InnerFlag[int64]{
-		Name:       "test-flag.test-field",
-		OuterFlag:  outerFlag,
-		InnerField: "test_field",
-		Validator: func(val int64) error {
-			if val < 0 {
-				return cli.Exit("Value must be non-negative", 1)
-			}
-			return nil
-		},
-	}
-
-	// Valid case
-	err := innerFlag.Set(innerFlag.Name, "42")
-	assert.NoError(t, err, "Expected no error for valid value, got: %v", err)
-
-	// Should trigger validator error
-	err = innerFlag.Set(innerFlag.Name, "-5")
-	assert.Error(t, err, "Expected error for invalid value, got none")
-}
-
-func TestWithInnerFlags(t *testing.T) {
-	outerFlag := &Flag[map[string]any]{Name: "outer"}
-	innerFlag := &InnerFlag[string]{
-		Name:       "outer.baz",
-		InnerField: "baz",
-	}
-
-	cmd := WithInnerFlags(cli.Command{
-		Name:  "test-command",
-		Flags: []cli.Flag{outerFlag},
-	}, map[string][]HasOuterFlag{
-		"outer": {innerFlag},
-	})
-
-	// Verify that the command now has both the original flag and inner flag
-	assert.Len(t, cmd.Flags, 2, "Expected 2 flags, got %d", len(cmd.Flags))
-	assert.Equal(t, outerFlag, cmd.Flags[0], "First flag should be outerFlag")
-	assert.Equal(t, innerFlag, cmd.Flags[1], "Second flag should be innerFlag")
-	assert.Same(t, outerFlag, innerFlag.OuterFlag, "innerFlag.OuterFlag should point to outerFlag")
-}
-
-func TestInnerFlagTypeNames(t *testing.T) {
-	tests := []struct {
-		name     string
-		flag     cli.DocGenerationFlag
-		expected string
-	}{
-		{"string", &InnerFlag[string]{}, "string"},
-		{"int64", &InnerFlag[int64]{}, "int"},
-		{"float64", &InnerFlag[float64]{}, "float"},
-		{"bool", &InnerFlag[bool]{}, "boolean"},
-		{"string slice", &InnerFlag[[]string]{}, "string"},
-		{"date", &InnerFlag[DateValue]{}, "date"},
-		{"datetime", &InnerFlag[DateTimeValue]{}, "datetime"},
-		{"time", &InnerFlag[TimeValue]{}, "time"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			typeName := tt.flag.TypeName()
-			assert.Equal(t, tt.expected, typeName, "Expected type name %q, got %q", tt.expected, typeName)
-		})
-	}
-}
-
-func TestInnerYamlHandling(t *testing.T) {
-	// Test with map value
-	t.Run("Parse YAML to map", func(t *testing.T) {
-		outerFlag := &Flag[map[string]any]{Name: "outer"}
-		innerFlag := &InnerFlag[map[string]any]{
-			Name:       "outer.baz",
-			OuterFlag:  outerFlag,
-			InnerField: "baz",
-		}
-
-		err := innerFlag.Set(innerFlag.Name, "{name: test, value: 42}")
-		assert.NoError(t, err)
-
-		// Retrieve and check the parsed YAML map
-		result, ok := outerFlag.Get().(map[string]any)
-		assert.True(t, ok, "Expected map[string]any from outerFlag.Get()")
-		yamlField, ok := result["baz"].(map[string]any)
-		assert.True(t, ok, "Expected map[string]any, got %T", result["baz"])
-		val := yamlField
-
-		if ok {
-			assert.Equal(t, map[string]any{"name": "test", "value": uint64(42)}, val)
-		}
-	})
-
-	// Test with invalid YAML
-	t.Run("Parse invalid YAML", func(t *testing.T) {
-		outerFlag := &Flag[map[string]any]{Name: "outer"}
-		innerFlag := &InnerFlag[map[string]any]{
-			Name:       "outer.baz",
-			OuterFlag:  outerFlag,
-			InnerField: "baz",
-		}
-
-		invalidYaml := `[not closed`
-		err := innerFlag.Set(innerFlag.Name, invalidYaml)
-		assert.Error(t, err)
-	})
-
-	// Test setting inner flags on a map multiple times
-	t.Run("Set inner flags on map multiple times", func(t *testing.T) {
-		outerFlag := &Flag[map[string]any]{Name: "outer"}
-
-		// Set first inner flag
-		firstInnerFlag := &InnerFlag[string]{
-			Name:       "outer.first-flag",
-			OuterFlag:  outerFlag,
-			InnerField: "first_field",
-		}
-
-		err := firstInnerFlag.Set(firstInnerFlag.Name, "first-value")
-		assert.NoError(t, err)
-
-		// Set second inner flag
-		secondInnerFlag := &InnerFlag[int64]{
-			Name:       "outer.second-flag",
-			OuterFlag:  outerFlag,
-			InnerField: "second_field",
-		}
-
-		err = secondInnerFlag.Set(secondInnerFlag.Name, "42")
-		assert.NoError(t, err)
-
-		// Verify both fields are set correctly
-		result := outerFlag.Get().(map[string]any)
-		assert.Equal(t, map[string]any{"first_field": "first-value", "second_field": int64(42)}, result)
-	})
-
-	// Test setting YAML and then an inner flag
-	t.Run("Set YAML and then inner flag", func(t *testing.T) {
-		outerFlag := &Flag[map[string]any]{Name: "outer"}
-
-		// First set the outer flag with YAML
-		err := outerFlag.Set(outerFlag.Name, `{existing: value, another: field}`)
-		assert.NoError(t, err)
-
-		// Then set an inner flag
-		innerFlag := &InnerFlag[string]{
-			Name:       "outer.inner-flag",
-			OuterFlag:  outerFlag,
-			InnerField: "new_field",
-		}
-
-		err = innerFlag.Set(innerFlag.Name, "inner-value")
-		assert.NoError(t, err)
-
-		// Verify both the YAML content and inner flag value
-		result := outerFlag.Get().(map[string]any)
-		assert.Equal(t, map[string]any{
-			"existing":  "value",
-			"another":   "field",
-			"new_field": "inner-value",
-		}, result)
-	})
-}
-
-func TestInnerFlagWithSliceType(t *testing.T) {
-	t.Run("Setting inner flags on slice of maps", func(t *testing.T) {
-		outerFlag := &Flag[[]map[string]any]{Name: "outer"}
-
-		// Set first inner flag (should create first item)
-		firstInnerFlag := &InnerFlag[string]{
-			Name:       "outer.name-flag",
-			OuterFlag:  outerFlag,
-			InnerField: "name",
-		}
-
-		err := firstInnerFlag.Set(firstInnerFlag.Name, "item1")
-		assert.NoError(t, err)
-
-		// Set second inner flag (should modify first item)
-		secondInnerFlag := &InnerFlag[int64]{
-			Name:       "outer.count-flag",
-			OuterFlag:  outerFlag,
-			InnerField: "count",
-		}
-
-		err = secondInnerFlag.Set(secondInnerFlag.Name, "42")
-		assert.NoError(t, err)
-
-		// Set name flag again (should create second item)
-		err = firstInnerFlag.Set(firstInnerFlag.Name, "item2")
-		assert.NoError(t, err)
-
-		// Verify the slice has two items with correct values
-		result := outerFlag.Get().([]map[string]any)
-
-		assert.Equal(t, []map[string]any{
-			{"name": "item1", "count": int64(42)},
-			{"name": "item2"},
-		}, result)
-		assert.Nil(t, result[1]["count"], "Second item should not have count field")
-	})
-
-	t.Run("Appending to existing slice", func(t *testing.T) {
-		// Initialize with existing items
-		outerFlag := &Flag[[]map[string]any]{Name: "outer"}
-		err := outerFlag.Set(outerFlag.Name, `{name: initial}`)
-		assert.NoError(t, err)
-
-		// Set inner flag to modify existing item
-		modifyFlag := &InnerFlag[string]{
-			Name:       "outer.value-flag",
-			OuterFlag:  outerFlag,
-			InnerField: "value",
-		}
-
-		err = modifyFlag.Set(modifyFlag.Name, "updated")
-		assert.NoError(t, err)
-
-		// Set inner flag to create new item
-		newItemFlag := &InnerFlag[string]{
-			Name:       "outer.name-flag",
-			OuterFlag:  outerFlag,
-			InnerField: "name",
-		}
-
-		err = newItemFlag.Set(newItemFlag.Name, "second")
-		assert.NoError(t, err)
-
-		// Verify both items
-		result := outerFlag.Get().([]map[string]any)
-		assert.Equal(t, []map[string]any{
-			{"name": "initial", "value": "updated"},
-			{"name": "second"},
-		}, result)
-	})
-}
diff --git a/internal/requestflag/requestflag.go b/internal/requestflag/requestflag.go
deleted file mode 100644
index 21a8a69..0000000
--- a/internal/requestflag/requestflag.go
+++ /dev/null
@@ -1,726 +0,0 @@
-package requestflag
-
-import (
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-	"unicode"
-
-	"github.com/goccy/go-yaml"
-	"github.com/urfave/cli/v3"
-)
-
-// Flag [T] is a generic flag base which can be used to implement the most
-// common interfaces used by urfave/cli. Additionally, it allows specifying
-// where in an HTTP request the flag values should be placed (e.g. query, body, etc.).
-type Flag[
-	T []any | []map[string]any | []DateTimeValue | []DateValue | []TimeValue | []string |
-		[]float64 | []int64 | []bool | any | map[string]any | DateTimeValue | DateValue | TimeValue |
-		string | float64 | int64 | bool,
-] struct {
-	Name        string               // name of the flag
-	Category    string               // category of the flag, if any
-	DefaultText string               // default text of the flag for usage purposes
-	HideDefault bool                 // whether to hide the default value in output
-	Usage       string               // usage string for help output
-	Sources     cli.ValueSourceChain // sources to load flag value from
-	Required    bool                 // whether the flag is required or not
-	Hidden      bool                 // whether to hide the flag in help output
-	Default     T                    // default value for this flag if not set by from any source
-	Aliases     []string             // aliases that are allowed for this flag
-	Validator   func(T) error        // custom function to validate this flag value
-
-	QueryPath  string // location in the request query string to put this flag's value
-	HeaderPath string // location in the request header to put this flag's value
-	BodyPath   string // location in the request body to put this flag's value
-	BodyRoot   bool   // if true, then use this value as the entire request body
-
-	// unexported fields for internal use
-	count      int       // number of times the flag has been set
-	hasBeenSet bool      // whether the flag has been set from env or file
-	applied    bool      // whether the flag has been applied to a flag set already
-	value      cli.Value // value representing this flag's value
-}
-
-// Type assertions to verify we implement the relevant urfave/cli interfaces
-var _ cli.CategorizableFlag = (*Flag[any])(nil)
-
-// InRequest interface for flags that should be included in HTTP requests
-type InRequest interface {
-	GetQueryPath() string
-	GetHeaderPath() string
-	GetBodyPath() string
-	IsBodyRoot() bool
-}
-
-func (f Flag[T]) GetQueryPath() string {
-	return f.QueryPath
-}
-
-func (f Flag[T]) GetHeaderPath() string {
-	return f.HeaderPath
-}
-
-func (f Flag[T]) GetBodyPath() string {
-	return f.BodyPath
-}
-
-func (f Flag[T]) IsBodyRoot() bool {
-	return f.BodyRoot
-}
-
-// The values that will be sent in different parts of a request.
-type RequestContents struct {
-	Queries map[string]any
-	Headers map[string]any
-	Body    any
-}
-
-// Extract query parameters, headers, and body values from command flags.
-func ExtractRequestContents(cmd *cli.Command) RequestContents {
-	bodyMap := make(map[string]any)
-	res := RequestContents{
-		Queries: make(map[string]any),
-		Headers: make(map[string]any),
-		Body:    bodyMap,
-	}
-
-	for _, flag := range cmd.Flags {
-		if !flag.IsSet() {
-			continue
-		}
-
-		value := flag.Get()
-		if toSend, ok := flag.(InRequest); ok {
-			if queryPath := toSend.GetQueryPath(); queryPath != "" {
-				res.Queries[queryPath] = value
-			}
-			if headerPath := toSend.GetHeaderPath(); headerPath != "" {
-				res.Headers[headerPath] = value
-			}
-			if toSend.IsBodyRoot() {
-				res.Body = value
-			} else if bodyPath := toSend.GetBodyPath(); bodyPath != "" {
-				bodyMap[bodyPath] = value
-			}
-		}
-	}
-	return res
-}
-
-func GetMissingRequiredFlags(cmd *cli.Command, body any) []cli.Flag {
-	missing := []cli.Flag{}
-	for _, flag := range cmd.Flags {
-		if flag.IsSet() {
-			continue
-		}
-
-		if required, ok := flag.(cli.RequiredFlag); ok && required.IsRequired() {
-			missing = append(missing, flag)
-			continue
-		}
-
-		if r, ok := flag.(RequiredFlagOrStdin); !ok || !r.IsRequiredAsFlagOrStdin() {
-			continue
-		}
-
-		if toSend, ok := flag.(InRequest); ok {
-			if toSend.IsBodyRoot() {
-				if body != nil {
-					continue
-				}
-			} else if bodyPath := toSend.GetBodyPath(); bodyPath != "" {
-				if bodyMap, ok := body.(map[string]any); ok {
-					if _, found := bodyMap[bodyPath]; found {
-						continue
-					}
-				}
-			}
-		}
-		missing = append(missing, flag)
-	}
-	return missing
-}
-
-// Implementation of the cli.Flag interface
-var _ cli.Flag = (*Flag[any])(nil) // Type assertion to ensure interface compliance
-
-func (f *Flag[T]) PreParse() error {
-	newVal := f.Default
-	f.value = &cliValue[T]{newVal}
-
-	// Validate the given default or values set from external sources as well
-	if f.Validator != nil {
-		if err := f.Validator(f.value.Get().(T)); err != nil {
-			return err
-		}
-	}
-	f.applied = true
-	return nil
-}
-
-func (f *Flag[T]) PostParse() error {
-	if !f.hasBeenSet {
-		if val, source, found := f.Sources.LookupWithSource(); found {
-			if val != "" || reflect.TypeOf(f.value).Kind() == reflect.String {
-				if err := f.Set(f.Name, val); err != nil {
-					return fmt.Errorf(
-						"could not parse %[1]q as %[2]T value from %[3]s for flag %[4]s: %[5]s",
-						val, f.value, source, f.Name, err,
-					)
-				}
-			} else if val == "" && reflect.TypeOf(f.value).Kind() == reflect.Bool {
-				_ = f.Set(f.Name, "false")
-			}
-
-			f.hasBeenSet = true
-		}
-	}
-	return nil
-}
-
-func (f *Flag[T]) Set(name string, val string) error {
-	// Initialize flag if needed
-	if !f.applied {
-		if err := f.PreParse(); err != nil {
-			return err
-		}
-		f.applied = true
-	}
-
-	f.count++
-
-	// If this is the first time setting a slice type, reset it to empty
-	// to avoid appending to the default value
-	if f.count == 1 && f.value != nil {
-		typ := reflect.TypeOf(f.Default)
-		if typ != nil && typ.Kind() == reflect.Slice {
-			// Create a new empty slice of the same type and set it
-			emptySlice := reflect.MakeSlice(typ, 0, 0).Interface()
-			f.value = &cliValue[T]{emptySlice.(T)}
-		}
-	}
-
-	if err := f.value.Set(val); err != nil {
-		return err
-	}
-
-	f.hasBeenSet = true
-
-	if f.Validator != nil {
-		if err := f.Validator(f.value.Get().(T)); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (f *Flag[T]) Get() any {
-	if f.value != nil {
-		return f.value.Get()
-	}
-	return f.Default
-}
-
-func (f *Flag[T]) String() string {
-	return cli.FlagStringer(f)
-}
-
-func (f *Flag[T]) IsSet() bool {
-	return f.hasBeenSet
-}
-
-func (f *Flag[T]) Names() []string {
-	return cli.FlagNames(f.Name, f.Aliases)
-}
-
-// Implementation for the cli.VisibleFlag interface
-var _ cli.VisibleFlag = (*Flag[any])(nil) // Type assertion to ensure interface compliance
-
-func (f *Flag[T]) IsVisible() bool {
-	return !f.Hidden
-}
-
-func (f *Flag[T]) GetCategory() string {
-	return f.Category
-}
-
-func (f *Flag[T]) SetCategory(c string) {
-	f.Category = c
-}
-
-// Implementation for the cli.RequiredFlag interface
-var _ cli.RequiredFlag = (*Flag[any])(nil) // Type assertion to ensure interface compliance
-
-func (f *Flag[T]) IsRequired() bool {
-	// Intentionally don't use `f.Required`, because request flags may be passed
-	// over stdin as well as by flag.
-	if f.BodyPath != "" || f.BodyRoot {
-		return false
-	}
-	return f.Required
-}
-
-type RequiredFlagOrStdin interface {
-	IsRequiredAsFlagOrStdin() bool
-}
-
-func (f *Flag[T]) IsRequiredAsFlagOrStdin() bool {
-	return f.Required
-}
-
-// Implementation for the cli.DocGenerationFlag interface
-var _ cli.DocGenerationFlag = (*Flag[any])(nil) // Type assertion to ensure interface compliance
-
-func (f *Flag[T]) TakesValue() bool {
-	var t T
-	return reflect.TypeOf(t) == nil || reflect.TypeOf(t).Kind() != reflect.Bool
-}
-
-func (f *Flag[T]) GetUsage() string {
-	return f.Usage
-}
-
-func (f *Flag[T]) GetValue() string {
-	if f.value == nil {
-		return ""
-	}
-	return f.value.String()
-}
-
-func (f *Flag[T]) GetDefaultText() string {
-	return f.DefaultText
-}
-
-// GetEnvVars returns the env vars for this flag
-func (f *Flag[T]) GetEnvVars() []string {
-	return f.Sources.EnvKeys()
-}
-
-func (f *Flag[T]) IsDefaultVisible() bool {
-	return !f.HideDefault
-}
-
-func (f *Flag[T]) TypeName() string {
-	ty := reflect.TypeOf(f.Default)
-	if ty == nil {
-		return ""
-	}
-
-	// Get base type name with special handling for built-in types
-	getTypeName := func(t reflect.Type) string {
-		switch t.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			return "int"
-		case reflect.Float32, reflect.Float64:
-			return "float"
-		case reflect.Bool:
-			return "boolean"
-		case reflect.String:
-			switch t.Name() {
-			case "DateTimeValue":
-				return "datetime"
-			case "DateValue":
-				return "date"
-			case "TimeValue":
-				return "time"
-			default:
-				return "string"
-			}
-		default:
-			if t.Name() == "" {
-				return "any"
-			}
-			return strings.ToLower(t.Name())
-		}
-	}
-
-	switch ty.Kind() {
-	case reflect.Slice:
-		elemType := ty.Elem()
-		return getTypeName(elemType)
-	case reflect.Map:
-		keyType := ty.Key()
-		valueType := ty.Elem()
-		return fmt.Sprintf("%s=%s", getTypeName(keyType), getTypeName(valueType))
-	default:
-		return getTypeName(ty)
-	}
-}
-
-// Implementation for the cli.DocGenerationMultiValueFlag interface
-var _ cli.DocGenerationMultiValueFlag = (*Flag[any])(nil) // Type assertion to ensure interface compliance
-
-func (f *Flag[T]) IsMultiValueFlag() bool {
-	if reflect.TypeOf(f.Default) == nil {
-		return false
-	}
-	kind := reflect.TypeOf(f.Default).Kind()
-	return kind == reflect.Slice || kind == reflect.Map
-}
-
-func (f *Flag[T]) IsBoolFlag() bool {
-	_, isBool := any(f.Default).(bool)
-	return isBool
-}
-
-// Implementation for the cli.Countable interface
-var _ cli.Countable = (*Flag[any])(nil) // Type assertion to ensure interface compliance
-
-func (f *Flag[T]) Count() int {
-	return f.count
-}
-
-// Implementation for the cli.LocalFlag interface
-var _ cli.LocalFlag = (*Flag[any])(nil) // Type assertion to ensure interface compliance
-
-func (f Flag[T]) IsLocal() bool {
-	// By default, all request flags are local, i.e. can be provided at any part of the CLI command.
-	return true
-}
-
-// cliValue is a generic implementation of cli.Value for common types
-type cliValue[
-	T []any | []map[string]any | []DateTimeValue | []DateValue | []TimeValue | []string | []float64 |
-		[]int64 | []bool | any | map[string]any | DateTimeValue | DateValue | TimeValue | string |
-		float64 | int64 | bool,
-] struct {
-	value T
-}
-
-// Take an argument string for a single argument and convert it into a typed
-// value for one of the supported CLI argument types
-func parseCLIArg[
-	T []any | []map[string]any | []DateTimeValue | []DateValue | []TimeValue | []string | []float64 |
-		[]int64 | []bool | any | map[string]any | DateTimeValue | DateValue | TimeValue | string |
-		float64 | int64 | bool,
-](value string) (T, error) {
-	var parsedValue any
-	var err error
-
-	var empty T
-	switch any(empty).(type) {
-	case string:
-		parsedValue = value
-	case int64:
-		parsedValue, err = strconv.ParseInt(value, 0, 64)
-	case float64:
-		parsedValue, err = strconv.ParseFloat(value, 64)
-	case bool:
-		parsedValue, err = strconv.ParseBool(value)
-	case DateTimeValue:
-		var dt DateTimeValue
-		err = (&dt).Parse(value)
-		if err == nil {
-			parsedValue = dt
-		}
-
-	case DateValue:
-		var d DateValue
-		err = (&d).Parse(value)
-		if err == nil {
-			parsedValue = d
-		}
-
-	case TimeValue:
-		var t TimeValue
-		err = (&t).Parse(value)
-		if err == nil {
-			parsedValue = t
-		}
-
-	default:
-		if strings.HasPrefix(value, "@") {
-			// File literals like @file.txt should work here
-			parsedValue = value
-		} else {
-			var yamlValue T
-			err = yaml.Unmarshal([]byte(value), &yamlValue)
-			if err == nil {
-				parsedValue = yamlValue
-			} else if allowAsLiteralString(value) {
-				parsedValue = value
-			} else {
-				parsedValue = nil
-				err = fmt.Errorf("failed to parse as YAML: %w", err)
-			}
-		}
-	}
-
-	// Nil needs to be handled specially because unmarshalling a YAML `null`
-	// causes problems when doing type assertions.
-	if parsedValue == nil {
-		parsedValue = (*struct{})(nil)
-	}
-
-	if err == nil {
-		if typedValue, ok := parsedValue.(T); ok {
-			return typedValue, nil
-		} else {
-			expectedType := reflect.TypeFor[T]()
-			err = fmt.Errorf("Couldn't convert %q (%v) to expected type %v", value, parsedValue, expectedType)
-		}
-	}
-	return empty, err
-
-}
-
-// Assuming this string failed to parse as valid YAML, this function will
-// return true for strings that can reasonably be interpreted as a string literal,
-// like identifiers (`foo_bar`), UUIDs (`945b2f0c-8e89-487a-b02c-f851c69ea459`),
-// base64 (`aGVsbG8=`), and qualified identifiers (`color.Red`). This should
-// not include strings that look like mistyped YAML (e.g. `{key:`)
-func allowAsLiteralString(s string) bool {
-	for _, c := range s {
-		if !unicode.IsLetter(c) && !unicode.IsDigit(c) &&
-			c != '_' && c != '-' && c != '.' && c != '=' {
-			return false
-		}
-	}
-	return true
-}
-
-// Parse the input string and set result as the cliValue's value
-func (c *cliValue[T]) Set(value string) error {
-	valueType := reflect.TypeOf(c.value)
-	// When setting slice values, we append to the existing values
-	// e.g. --foo 10 --foo 20 --foo 30 => [10, 20, 30]
-	if valueType != nil && valueType.Kind() == reflect.Slice {
-		elemType := valueType.Elem()
-
-		var singleElem any
-		var err error
-		switch elemType.Kind() {
-		case reflect.String:
-			singleElem, err = parseCLIArg[string](value)
-		case reflect.Int64:
-			singleElem, err = parseCLIArg[int64](value)
-		case reflect.Float64:
-			singleElem, err = parseCLIArg[float64](value)
-		case reflect.Bool:
-			singleElem, err = parseCLIArg[bool](value)
-		default:
-			// Check for special types by name
-			switch elemType.Name() {
-			case "DateTimeValue":
-				singleElem, err = parseCLIArg[DateTimeValue](value)
-			case "DateValue":
-				singleElem, err = parseCLIArg[DateValue](value)
-			case "TimeValue":
-				singleElem, err = parseCLIArg[TimeValue](value)
-			default:
-				// This handles []map[string]any
-				if elemType.Kind() == reflect.Map && elemType.Key().Kind() == reflect.String {
-					singleElem, err = parseCLIArg[map[string]any](value)
-				} else {
-					singleElem, err = parseCLIArg[any](value)
-				}
-			}
-		}
-
-		if err != nil {
-			return err
-		}
-
-		// Append the new element to the slice
-		sliceValue := reflect.ValueOf(c.value)
-		if !sliceValue.IsValid() || sliceValue.IsNil() {
-			// Create a new slice if the current one is nil
-			sliceValue = reflect.MakeSlice(valueType, 0, 1)
-		}
-
-		// Append the new element
-		newElem := reflect.ValueOf(singleElem)
-		sliceValue = reflect.Append(sliceValue, newElem)
-
-		// Set the updated slice back to c.value
-		c.value = sliceValue.Interface().(T)
-	} else {
-		// For non-slice types, simply parse and set the value
-		if parsedValue, err := parseCLIArg[T](value); err != nil {
-			return err
-		} else {
-			c.value = parsedValue
-		}
-	}
-
-	return nil
-}
-
-func (c *cliValue[T]) Get() any {
-	return c.value
-}
-
-func (c *cliValue[T]) String() string {
-	switch v := any(c.value).(type) {
-	case string, int, int64, float64, bool, DateTimeValue, DateValue, TimeValue,
-		[]string, []int, []int64, []float64, []bool, []DateTimeValue, []DateValue, []TimeValue:
-		// For basic types, use standard string representation
-		return fmt.Sprintf("%v", v)
-
-	default:
-		// For complex types, convert to YAML
-		yamlBytes, err := yaml.MarshalWithOptions(c.value, yaml.Flow(true))
-		if err != nil {
-			// Fall back to standard format if YAML conversion fails
-			return fmt.Sprintf("%v", c.value)
-		}
-		return string(yamlBytes)
-	}
-}
-
-func (c *cliValue[T]) IsBoolFlag() bool {
-	_, ok := any(c.value).(bool)
-	return ok
-}
-
-// Time-related value types
-type DateValue string
-type DateTimeValue string
-type TimeValue string
-
-// String methods for time-related types
-func (d DateValue) String() string {
-	return string(d)
-}
-
-func (d DateTimeValue) String() string {
-	return string(d)
-}
-
-func (t TimeValue) String() string {
-	return string(t)
-}
-
-// parseTimeWithFormats attempts to parse a string using multiple formats
-func parseTimeWithFormats(s string, formats []string) (time.Time, error) {
-	var lastErr error
-	for _, format := range formats {
-		t, err := time.Parse(format, s)
-		if err == nil {
-			return t, nil
-		}
-		lastErr = err
-	}
-	return time.Time{}, lastErr
-}
-
-// Parse methods for time-related types
-func (d *DateValue) Parse(s string) error {
-	formats := []string{
-		"2006-01-02",
-		"01/02/2006",
-		"Jan 2, 2006",
-		"January 2, 2006",
-		"2-Jan-2006",
-	}
-
-	t, err := parseTimeWithFormats(s, formats)
-	if err != nil {
-		return fmt.Errorf("unable to parse date: %v", err)
-	}
-
-	*d = DateValue(t.Format("2006-01-02"))
-	return nil
-}
-
-func (d *DateTimeValue) Parse(s string) error {
-	formats := []string{
-		time.RFC3339,
-		time.RFC3339Nano,
-		"2006-01-02T15:04:05",
-		"2006-01-02 15:04:05",
-		time.RFC1123,
-		time.RFC822,
-		time.ANSIC,
-	}
-
-	t, err := parseTimeWithFormats(s, formats)
-	if err != nil {
-		return fmt.Errorf("unable to parse datetime: %v", err)
-	}
-
-	*d = DateTimeValue(t.Format(time.RFC3339))
-	return nil
-}
-
-func (t *TimeValue) Parse(s string) error {
-	formats := []string{
-		"15:04:05",
-		"15:04:05.999999999Z07:00",
-		"3:04:05PM",
-		"3:04 PM",
-		"15:04",
-		time.Kitchen,
-	}
-
-	parsedTime, err := parseTimeWithFormats(s, formats)
-	if err != nil {
-		return fmt.Errorf("unable to parse time: %v", err)
-	}
-
-	*t = TimeValue(parsedTime.Format("15:04:05"))
-	return nil
-}
-
-// Allow setting inner fields on other flags (e.g. --foo.baz can set the "baz"
-// field on the --foo flag)
-type SettableInnerField interface {
-	SetInnerField(string, any)
-}
-
-func (f *Flag[T]) SetInnerField(field string, val any) {
-	if f.value == nil {
-		f.value = &cliValue[T]{}
-	}
-
-	if settableInnerField, ok := f.value.(SettableInnerField); ok {
-		settableInnerField.SetInnerField(field, val)
-		f.hasBeenSet = true
-	} else {
-		panic(fmt.Sprintf("Cannot set inner field: %v", f.value))
-	}
-}
-
-func (c *cliValue[T]) SetInnerField(field string, val any) {
-	flagVal := c.value
-	flagValReflect := reflect.ValueOf(flagVal)
-	switch flagValReflect.Kind() {
-	case reflect.Slice:
-		if flagValReflect.Type().Elem().Kind() != reflect.Map {
-			return
-		}
-
-		sliceLen := flagValReflect.Len()
-		if sliceLen > 0 {
-			// Check if the last element already has the InnerField
-			lastElement := flagValReflect.Index(sliceLen - 1).Interface().(map[string]any)
-			if _, hasInnerField := lastElement[field]; !hasInnerField {
-				// Last element doesn't have the field, set it
-				lastElement[field] = val
-				return
-			}
-		}
-
-		// Create a new map and append it to the slice
-		newMap := map[string]any{field: val}
-		switch sliceVal := any(c.value).(type) {
-		case []map[string]any:
-			c.value = any(append(sliceVal, newMap)).(T)
-		case []any:
-			c.value = any(append(sliceVal, newMap)).(T)
-		}
-
-	case reflect.Map:
-		mapVal, ok := any(flagVal).(map[string]any)
-		if !ok || mapVal == nil {
-			mapVal = map[string]any{field: val}
-			c.value = any(mapVal).(T)
-		} else {
-			mapVal[field] = val
-		}
-	}
-}
diff --git a/internal/requestflag/requestflag_test.go b/internal/requestflag/requestflag_test.go
deleted file mode 100644
index 9751904..0000000
--- a/internal/requestflag/requestflag_test.go
+++ /dev/null
@@ -1,590 +0,0 @@
-package requestflag
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/goccy/go-yaml"
-	"github.com/stretchr/testify/assert"
-	"github.com/urfave/cli/v3"
-)
-
-func TestDateValueParse(t *testing.T) {
-	tests := []struct {
-		name    string
-		input   string
-		want    string
-		wantErr bool
-	}{
-		{
-			name:    "ISO format",
-			input:   "2023-05-15",
-			want:    "2023-05-15",
-			wantErr: false,
-		},
-		{
-			name:    "US format",
-			input:   "05/15/2023",
-			want:    "2023-05-15",
-			wantErr: false,
-		},
-		{
-			name:    "Short month format",
-			input:   "May 15, 2023",
-			want:    "2023-05-15",
-			wantErr: false,
-		},
-		{
-			name:    "Long month format",
-			input:   "January 15, 2023",
-			want:    "2023-01-15",
-			wantErr: false,
-		},
-		{
-			name:    "British format",
-			input:   "15-Jan-2023",
-			want:    "2023-01-15",
-			wantErr: false,
-		},
-		{
-			name:    "Invalid format",
-			input:   "not a date",
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var d DateValue
-			err := d.Parse(tt.input)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				assert.Equal(t, tt.want, d.String())
-			}
-		})
-	}
-}
-
-func TestDateTimeValueParse(t *testing.T) {
-	tests := []struct {
-		name    string
-		input   string
-		wantErr bool
-	}{
-		{
-			name:    "RFC3339",
-			input:   "2023-05-15T14:30:45Z",
-			wantErr: false,
-		},
-		{
-			name:    "ISO with timezone",
-			input:   "2023-05-15T14:30:45+02:00",
-			wantErr: false,
-		},
-		{
-			name:    "ISO without timezone",
-			input:   "2023-05-15T14:30:45",
-			wantErr: false,
-		},
-		{
-			name:    "Space separated",
-			input:   "2023-05-15 14:30:45",
-			wantErr: false,
-		},
-		{
-			name:    "RFC1123",
-			input:   "Mon, 15 May 2023 14:30:45 GMT",
-			wantErr: false,
-		},
-		{
-			name:    "RFC822",
-			input:   "15 May 23 14:30 GMT",
-			wantErr: false,
-		},
-		{
-			name:    "ANSIC",
-			input:   "Mon Jan 2 15:04:05 2006",
-			wantErr: false,
-		},
-		{
-			name:    "Invalid format",
-			input:   "not a datetime",
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var d DateTimeValue
-			err := d.Parse(tt.input)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-
-				// Parse the string back to ensure it's valid RFC3339
-				_, parseErr := time.Parse(time.RFC3339, d.String())
-				assert.NoError(t, parseErr)
-			}
-		})
-	}
-}
-
-func TestTimeValueParse(t *testing.T) {
-	tests := []struct {
-		name    string
-		input   string
-		want    string
-		wantErr bool
-	}{
-		{
-			name:    "24-hour format",
-			input:   "14:30:45",
-			want:    "14:30:45",
-			wantErr: false,
-		},
-		{
-			name:    "12-hour format with seconds",
-			input:   "2:30:45PM",
-			want:    "14:30:45",
-			wantErr: false,
-		},
-		{
-			name:    "12-hour format without seconds",
-			input:   "2:30 PM",
-			want:    "14:30:00",
-			wantErr: false,
-		},
-		{
-			name:    "24-hour without seconds",
-			input:   "14:30",
-			want:    "14:30:00",
-			wantErr: false,
-		},
-		{
-			name:    "Kitchen format",
-			input:   "2:30PM",
-			want:    "14:30:00",
-			wantErr: false,
-		},
-		{
-			name:    "Invalid format",
-			input:   "not a time",
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var tv TimeValue
-			err := tv.Parse(tt.input)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				assert.Equal(t, tt.want, tv.String())
-			}
-		})
-	}
-}
-
-func TestRequestParams(t *testing.T) {
-	t.Run("map body type", func(t *testing.T) {
-		// Create a mock command with flags
-		cmd := &cli.Command{
-			Name: "test",
-		}
-
-		// Create string flag with body path
-		stringFlag := &Flag[string]{
-			Name:       "string-flag",
-			Default:    "default-string",
-			BodyPath:   "string_field",
-			value:      &cliValue[string]{value: "test-value"},
-			hasBeenSet: true,
-		}
-
-		// Create int flag with header path
-		intFlag := &Flag[int64]{
-			Name:       "int-flag",
-			Default:    42,
-			HeaderPath: "X-Int-Value",
-			value:      &cliValue[int64]{value: 99},
-			hasBeenSet: true,
-		}
-
-		// Create bool flag with query path
-		boolFlag := &Flag[bool]{
-			Name:       "bool-flag",
-			Default:    false,
-			QueryPath:  "include_details",
-			value:      &cliValue[bool]{value: true},
-			hasBeenSet: true,
-		}
-
-		// Create date flag with multiple paths
-		dateFlag := &Flag[DateValue]{
-			Name:       "date-flag",
-			Default:    DateValue("2023-01-01"),
-			BodyPath:   "effective_date",
-			HeaderPath: "X-Effective-Date",
-			QueryPath:  "as_of_date",
-			value:      &cliValue[DateValue]{value: DateValue("2023-05-15")},
-			hasBeenSet: true,
-		}
-
-		// Create flag with no path
-		noPathFlag := &Flag[string]{
-			Name:       "no-path-flag",
-			Default:    "no-path",
-			value:      &cliValue[string]{value: "no-path-value"},
-			hasBeenSet: true,
-		}
-
-		// Create unset flag
-		unsetFlag := &Flag[string]{
-			Name:       "unset-flag",
-			Default:    "unset",
-			BodyPath:   "should_not_appear",
-			value:      &cliValue[string]{value: "unset-value"},
-			hasBeenSet: false,
-		}
-
-		cmd.Flags = []cli.Flag{stringFlag, intFlag, boolFlag, dateFlag, noPathFlag, unsetFlag}
-
-		// Test the RequestParams function
-		contents := ExtractRequestContents(cmd)
-
-		// Verify query parameters
-		assert.Equal(t, true, contents.Queries["include_details"])
-		assert.Equal(t, DateValue("2023-05-15"), contents.Queries["as_of_date"])
-		assert.Len(t, contents.Queries, 2)
-
-		// Verify headers
-		assert.Equal(t, int64(99), contents.Headers["X-Int-Value"])
-		assert.Equal(t, DateValue("2023-05-15"), contents.Headers["X-Effective-Date"])
-		assert.Len(t, contents.Headers, 2)
-
-		// Verify body
-		bodyMap, ok := contents.Body.(map[string]any)
-		assert.True(t, ok, "Expected body to be map[string]any, got %T", contents.Body)
-		assert.Equal(t, "test-value", bodyMap["string_field"])
-		assert.Equal(t, DateValue("2023-05-15"), bodyMap["effective_date"])
-		assert.Len(t, bodyMap, 2)
-
-		// Verify the unset flag didn't make it into the maps
-		assert.NotContains(t, contents.Body, "should_not_appear")
-	})
-
-	t.Run("non-map body type", func(t *testing.T) {
-		// Create a mock command with flags
-		cmd := &cli.Command{
-			Name: "test",
-			Flags: []cli.Flag{
-				&Flag[int64]{
-					Name:     "int-body-flag",
-					Default:  0,
-					BodyRoot: true,
-				},
-			},
-		}
-		cmd.Set("int-body-flag", "42")
-
-		contents := ExtractRequestContents(cmd)
-		intBody, ok := contents.Body.(int64)
-		assert.True(t, ok, "Expected body to be int64, got %T", contents.Body)
-		assert.Equal(t, int64(42), intBody)
-	})
-}
-
-func TestFlagSet(t *testing.T) {
-	strFlag := &Flag[string]{
-		Name:    "string-flag",
-		Default: "default-string",
-	}
-
-	superstitiousIntFlag := &Flag[int64]{
-		Name:    "int-flag",
-		Default: 42,
-		Validator: func(val int64) error {
-			if val == 13 {
-				return fmt.Errorf("Unlucky number!")
-			}
-			return nil
-		},
-	}
-
-	boolFlag := &Flag[bool]{
-		Name:    "bool-flag",
-		Default: false,
-	}
-
-	// Test initialization and setting
-	t.Run("PreParse initialization", func(t *testing.T) {
-		assert.NoError(t, strFlag.PreParse())
-		assert.True(t, strFlag.applied)
-		assert.Equal(t, "default-string", strFlag.Get())
-	})
-
-	t.Run("Set string flag", func(t *testing.T) {
-		assert.NoError(t, strFlag.Set("string-flag", "new-value"))
-		assert.Equal(t, "new-value", strFlag.Get())
-		assert.True(t, strFlag.IsSet())
-	})
-
-	t.Run("Set int flag with valid value", func(t *testing.T) {
-		assert.NoError(t, superstitiousIntFlag.Set("int-flag", "100"))
-		assert.Equal(t, int64(100), superstitiousIntFlag.Get())
-		assert.True(t, superstitiousIntFlag.IsSet())
-	})
-
-	t.Run("Set int flag with invalid value", func(t *testing.T) {
-		assert.Error(t, superstitiousIntFlag.Set("int-flag", "not-an-int"))
-	})
-
-	t.Run("Set int flag with validator failing", func(t *testing.T) {
-		assert.Error(t, superstitiousIntFlag.Set("int-flag", "13"))
-	})
-
-	t.Run("Set bool flag", func(t *testing.T) {
-		assert.NoError(t, boolFlag.Set("bool-flag", "true"))
-		assert.Equal(t, true, boolFlag.Get())
-		assert.True(t, boolFlag.IsSet())
-	})
-
-	t.Run("Set slice flag with multiple values", func(t *testing.T) {
-		sliceFlag := &Flag[[]int64]{
-			Name:    "slice-flag",
-			Default: []int64{},
-		}
-
-		// Initialize the flag
-		assert.NoError(t, sliceFlag.PreParse())
-
-		// First set
-		assert.NoError(t, sliceFlag.Set("slice-flag", "10"))
-
-		// Subsequent setting should append, not replace
-		assert.NoError(t, sliceFlag.Set("slice-flag", "20"))
-		assert.NoError(t, sliceFlag.Set("slice-flag", "30"))
-
-		// Verify that we have both values in the slice
-		result := sliceFlag.Get()
-		assert.Equal(t, []int64{10, 20, 30}, result)
-		assert.True(t, sliceFlag.IsSet())
-	})
-
-	t.Run("Set slice flag with a nonempty default", func(t *testing.T) {
-		sliceFlag := &Flag[[]int64]{
-			Name:    "slice-flag",
-			Default: []int64{99, 100},
-		}
-
-		assert.NoError(t, sliceFlag.PreParse())
-		assert.NoError(t, sliceFlag.Set("slice-flag", "10"))
-		assert.NoError(t, sliceFlag.Set("slice-flag", "20"))
-		assert.NoError(t, sliceFlag.Set("slice-flag", "30"))
-
-		// Verify that we have clobbered the default value instead of appending
-		// to it.
-		result := sliceFlag.Get()
-		assert.Equal(t, []int64{10, 20, 30}, result)
-		assert.True(t, sliceFlag.IsSet())
-	})
-}
-
-func TestParseTimeWithFormats(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		formats  []string
-		wantTime time.Time
-		wantErr  bool
-	}{
-		{
-			name:     "RFC3339 format",
-			input:    "2023-05-15T14:30:45Z",
-			formats:  []string{time.RFC3339},
-			wantTime: time.Date(2023, 5, 15, 14, 30, 45, 0, time.UTC),
-			wantErr:  false,
-		},
-		{
-			name:     "Multiple formats - first matches",
-			input:    "2023-05-15",
-			formats:  []string{"2006-01-02", time.RFC3339},
-			wantTime: time.Date(2023, 5, 15, 0, 0, 0, 0, time.UTC),
-			wantErr:  false,
-		},
-		{
-			name:     "Multiple formats - second matches",
-			input:    "15/05/2023",
-			formats:  []string{"2006-01-02", "02/01/2006"},
-			wantTime: time.Date(2023, 5, 15, 0, 0, 0, 0, time.UTC),
-			wantErr:  false,
-		},
-		{
-			name:     "No matching format",
-			input:    "not a date",
-			formats:  []string{"2006-01-02", time.RFC3339},
-			wantTime: time.Time{},
-			wantErr:  true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := parseTimeWithFormats(tt.input, tt.formats)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				assert.True(t, tt.wantTime.Equal(got), "Expected %v, got %v", tt.wantTime, got)
-			}
-		})
-	}
-}
-
-func TestYamlHandling(t *testing.T) {
-	// Test with any value
-	t.Run("Parse YAML to any", func(t *testing.T) {
-		cv := &cliValue[any]{}
-		err := cv.Set("name: test\nvalue: 42\n")
-		assert.NoError(t, err)
-
-		// The value should be a map
-		val, ok := cv.Get().(map[string]any)
-		assert.True(t, ok, "Expected map[string]any, got %T", cv.Get())
-
-		if ok {
-			assert.Equal(t, "test", val["name"])
-			assert.Equal(t, uint64(42), val["value"])
-		}
-
-		// The string representation should be valid YAML
-		strVal := cv.String()
-		var parsed map[string]any
-		err = yaml.Unmarshal([]byte(strVal), &parsed)
-		assert.NoError(t, err)
-		assert.Equal(t, "test", parsed["name"])
-		assert.Equal(t, uint64(42), parsed["value"])
-	})
-
-	// Test with array
-	t.Run("Parse YAML array", func(t *testing.T) {
-		cv := &cliValue[any]{}
-		err := cv.Set("- item1\n- item2\n- item3\n")
-		assert.NoError(t, err)
-
-		// The value should be a slice
-		val, ok := cv.Get().([]any)
-		assert.True(t, ok, "Expected []any, got %T", cv.Get())
-
-		if ok {
-			assert.Len(t, val, 3)
-			assert.Equal(t, "item1", val[0])
-			assert.Equal(t, "item2", val[1])
-			assert.Equal(t, "item3", val[2])
-		}
-	})
-
-	t.Run("Parse @file.txt as YAML", func(t *testing.T) {
-		flag := &Flag[any]{
-			Name:    "file-flag",
-			Default: nil,
-		}
-		assert.NoError(t, flag.PreParse())
-		assert.NoError(t, flag.Set("file-flag", "@file.txt"))
-
-		val := flag.Get()
-		assert.Equal(t, "@file.txt", val)
-	})
-
-	t.Run("Parse @file.txt list as YAML", func(t *testing.T) {
-		flag := &Flag[[]any]{
-			Name:    "file-flag",
-			Default: nil,
-		}
-		assert.NoError(t, flag.PreParse())
-		assert.NoError(t, flag.Set("file-flag", "@file1.txt"))
-		assert.NoError(t, flag.Set("file-flag", "@file2.txt"))
-
-		val := flag.Get()
-		assert.Equal(t, []any{"@file1.txt", "@file2.txt"}, val)
-	})
-
-	t.Run("Parse identifiers as YAML", func(t *testing.T) {
-		tests := []string{
-			"hello",
-			"e4e355fa-b03b-4c57-a73d-25c9733eec79",
-			"foo_bar",
-			"Color.Red",
-			"aGVsbG8=",
-		}
-		for _, test := range tests {
-			flag := &Flag[any]{
-				Name:    "flag",
-				Default: nil,
-			}
-			assert.NoError(t, flag.PreParse())
-			assert.NoError(t, flag.Set("flag", test))
-
-			val := flag.Get()
-			assert.Equal(t, test, val)
-		}
-
-		for _, test := range tests {
-			flag := &Flag[[]any]{
-				Name:    "identifier",
-				Default: nil,
-			}
-			assert.NoError(t, flag.PreParse())
-			assert.NoError(t, flag.Set("identifier", test))
-			assert.NoError(t, flag.Set("identifier", test))
-
-			val := flag.Get()
-			assert.Equal(t, []any{test, test}, val)
-		}
-	})
-
-	// Test with invalid YAML
-	t.Run("Parse invalid YAML", func(t *testing.T) {
-		invalidYaml := `[not closed`
-		cv := &cliValue[any]{}
-		err := cv.Set(invalidYaml)
-		assert.Error(t, err)
-	})
-}
-
-func TestFlagTypeNames(t *testing.T) {
-	tests := []struct {
-		name     string
-		flag     cli.DocGenerationFlag
-		expected string
-	}{
-		{"string", &Flag[string]{}, "string"},
-		{"int64", &Flag[int64]{}, "int"},
-		{"float64", &Flag[float64]{}, "float"},
-		{"bool", &Flag[bool]{}, "boolean"},
-		{"string slice", &Flag[[]string]{}, "string"},
-		{"date", &Flag[DateValue]{}, "date"},
-		{"datetime", &Flag[DateTimeValue]{}, "datetime"},
-		{"time", &Flag[TimeValue]{}, "time"},
-		{"date slice", &Flag[[]DateValue]{}, "date"},
-		{"datetime slice", &Flag[[]DateTimeValue]{}, "datetime"},
-		{"time slice", &Flag[[]TimeValue]{}, "time"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			typeName := tt.flag.TypeName()
-			assert.Equal(t, tt.expected, typeName, "Expected type name %q, got %q", tt.expected, typeName)
-		})
-	}
-}
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..0895948
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,2253 @@
+{
+  "name": "beeper-cli",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "beeper-cli",
+      "version": "0.0.0",
+      "license": "MIT",
+      "dependencies": {
+        "@beeper/desktop-api": "^5.0.0",
+        "@oclif/core": "^4.11.2",
+        "@oclif/plugin-autocomplete": "^3.2.49",
+        "@oclif/plugin-help": "^6.2.48",
+        "@oclif/plugin-not-found": "^3.2.85",
+        "figures": "^6.1.0",
+        "ink": "^7.0.3",
+        "ink-spinner": "^5.0.0",
+        "react": "^19.2.6"
+      },
+      "bin": {
+        "beeper": "bin/run.js"
+      },
+      "devDependencies": {
+        "@types/node": "^25.7.0",
+        "@types/react": "^19.2.14",
+        "tsx": "^4.21.0",
+        "typescript": "^6.0.3"
+      }
+    },
+    "node_modules/@alcalzone/ansi-tokenize": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/@alcalzone/ansi-tokenize/-/ansi-tokenize-0.3.0.tgz",
+      "integrity": "sha512-p+CMKJ93HFmLkjXKlXiVGlMQEuRb6H0MokBSwUsX+S6BRX8eV5naFZpQJFfJHjRZY0Hmnqy1/r6UWl3x+19zYA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.2.1",
+        "is-fullwidth-code-point": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@alcalzone/ansi-tokenize/node_modules/ansi-styles": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/@alcalzone/ansi-tokenize/node_modules/is-fullwidth-code-point": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.1.0.tgz",
+      "integrity": "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "get-east-asian-width": "^1.3.1"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@beeper/desktop-api": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@beeper/desktop-api/-/desktop-api-5.0.0.tgz",
+      "integrity": "sha512-f9GhxQw6E0VMiVJGcdkUPNc6qCypaQlgMgxG6yU2lLy9gzx8xEObYnJbuhmT+HBg2SaQzNB33fC5ZT4OL3GnQw==",
+      "license": "MIT"
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.7.tgz",
+      "integrity": "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.7.tgz",
+      "integrity": "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.7.tgz",
+      "integrity": "sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.7.tgz",
+      "integrity": "sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.7.tgz",
+      "integrity": "sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.7.tgz",
+      "integrity": "sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.7.tgz",
+      "integrity": "sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.7.tgz",
+      "integrity": "sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.7.tgz",
+      "integrity": "sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.7.tgz",
+      "integrity": "sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.7.tgz",
+      "integrity": "sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.7.tgz",
+      "integrity": "sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.7.tgz",
+      "integrity": "sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.7.tgz",
+      "integrity": "sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.7.tgz",
+      "integrity": "sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.7.tgz",
+      "integrity": "sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.7.tgz",
+      "integrity": "sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.7.tgz",
+      "integrity": "sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.7.tgz",
+      "integrity": "sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.7.tgz",
+      "integrity": "sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.7.tgz",
+      "integrity": "sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.7.tgz",
+      "integrity": "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.7.tgz",
+      "integrity": "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@inquirer/ansi": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/ansi/-/ansi-1.0.2.tgz",
+      "integrity": "sha512-S8qNSZiYzFd0wAcyG5AXCvUHC5Sr7xpZ9wZ2py9XR88jUz8wooStVx5M6dRzczbBWjic9NP7+rY0Xi7qqK/aMQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@inquirer/checkbox": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/checkbox/-/checkbox-4.3.2.tgz",
+      "integrity": "sha512-VXukHf0RR1doGe6Sm4F0Em7SWYLTHSsbGfJdS9Ja2bX5/D5uwVOEjr07cncLROdBvmnvCATYEWlHqYmXv2IlQA==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^1.0.2",
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/figures": "^1.0.15",
+        "@inquirer/type": "^3.0.10",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/confirm": {
+      "version": "5.1.21",
+      "resolved": "https://registry.npmjs.org/@inquirer/confirm/-/confirm-5.1.21.tgz",
+      "integrity": "sha512-KR8edRkIsUayMXV+o3Gv+q4jlhENF9nMYUZs9PA2HzrXeHI8M5uDag70U7RJn9yyiMZSbtF5/UexBtAVtZGSbQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/core": {
+      "version": "10.3.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/core/-/core-10.3.2.tgz",
+      "integrity": "sha512-43RTuEbfP8MbKzedNqBrlhhNKVwoK//vUFNW3Q3vZ88BLcrs4kYpGg+B2mm5p2K/HfygoCxuKwJJiv8PbGmE0A==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^1.0.2",
+        "@inquirer/figures": "^1.0.15",
+        "@inquirer/type": "^3.0.10",
+        "cli-width": "^4.1.0",
+        "mute-stream": "^2.0.0",
+        "signal-exit": "^4.1.0",
+        "wrap-ansi": "^6.2.0",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/core/node_modules/wrap-ansi": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
+      "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@inquirer/editor": {
+      "version": "4.2.23",
+      "resolved": "https://registry.npmjs.org/@inquirer/editor/-/editor-4.2.23.tgz",
+      "integrity": "sha512-aLSROkEwirotxZ1pBaP8tugXRFCxW94gwrQLxXfrZsKkfjOYC1aRvAZuhpJOb5cu4IBTJdsCigUlf2iCOu4ZDQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/external-editor": "^1.0.3",
+        "@inquirer/type": "^3.0.10"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/expand": {
+      "version": "4.0.23",
+      "resolved": "https://registry.npmjs.org/@inquirer/expand/-/expand-4.0.23.tgz",
+      "integrity": "sha512-nRzdOyFYnpeYTTR2qFwEVmIWypzdAx/sIkCMeTNTcflFOovfqUk+HcFhQQVBftAh9gmGrpFj6QcGEqrDMDOiew==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/external-editor": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@inquirer/external-editor/-/external-editor-1.0.3.tgz",
+      "integrity": "sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==",
+      "license": "MIT",
+      "dependencies": {
+        "chardet": "^2.1.1",
+        "iconv-lite": "^0.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/figures": {
+      "version": "1.0.15",
+      "resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-1.0.15.tgz",
+      "integrity": "sha512-t2IEY+unGHOzAaVM5Xx6DEWKeXlDDcNPeDyUpsRc6CUhBfU3VQOEl+Vssh7VNp1dR8MdUJBWhuObjXCsVpjN5g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@inquirer/input": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@inquirer/input/-/input-4.3.1.tgz",
+      "integrity": "sha512-kN0pAM4yPrLjJ1XJBjDxyfDduXOuQHrBB8aLDMueuwUGn+vNpF7Gq7TvyVxx8u4SHlFFj4trmj+a2cbpG4Jn1g==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/number": {
+      "version": "3.0.23",
+      "resolved": "https://registry.npmjs.org/@inquirer/number/-/number-3.0.23.tgz",
+      "integrity": "sha512-5Smv0OK7K0KUzUfYUXDXQc9jrf8OHo4ktlEayFlelCjwMXz0299Y8OrI+lj7i4gCBY15UObk76q0QtxjzFcFcg==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/password": {
+      "version": "4.0.23",
+      "resolved": "https://registry.npmjs.org/@inquirer/password/-/password-4.0.23.tgz",
+      "integrity": "sha512-zREJHjhT5vJBMZX/IUbyI9zVtVfOLiTO66MrF/3GFZYZ7T4YILW5MSkEYHceSii/KtRk+4i3RE7E1CUXA2jHcA==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^1.0.2",
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/prompts": {
+      "version": "7.10.1",
+      "resolved": "https://registry.npmjs.org/@inquirer/prompts/-/prompts-7.10.1.tgz",
+      "integrity": "sha512-Dx/y9bCQcXLI5ooQ5KyvA4FTgeo2jYj/7plWfV5Ak5wDPKQZgudKez2ixyfz7tKXzcJciTxqLeK7R9HItwiByg==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/checkbox": "^4.3.2",
+        "@inquirer/confirm": "^5.1.21",
+        "@inquirer/editor": "^4.2.23",
+        "@inquirer/expand": "^4.0.23",
+        "@inquirer/input": "^4.3.1",
+        "@inquirer/number": "^3.0.23",
+        "@inquirer/password": "^4.0.23",
+        "@inquirer/rawlist": "^4.1.11",
+        "@inquirer/search": "^3.2.2",
+        "@inquirer/select": "^4.4.2"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/rawlist": {
+      "version": "4.1.11",
+      "resolved": "https://registry.npmjs.org/@inquirer/rawlist/-/rawlist-4.1.11.tgz",
+      "integrity": "sha512-+LLQB8XGr3I5LZN/GuAHo+GpDJegQwuPARLChlMICNdwW7OwV2izlCSCxN6cqpL0sMXmbKbFcItJgdQq5EBXTw==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/type": "^3.0.10",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/search": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/search/-/search-3.2.2.tgz",
+      "integrity": "sha512-p2bvRfENXCZdWF/U2BXvnSI9h+tuA8iNqtUKb9UWbmLYCRQxd8WkvwWvYn+3NgYaNwdUkHytJMGG4MMLucI1kA==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/figures": "^1.0.15",
+        "@inquirer/type": "^3.0.10",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/select": {
+      "version": "4.4.2",
+      "resolved": "https://registry.npmjs.org/@inquirer/select/-/select-4.4.2.tgz",
+      "integrity": "sha512-l4xMuJo55MAe+N7Qr4rX90vypFwCajSakx59qe/tMaC1aEHWLyw68wF4o0A4SLAY4E0nd+Vt+EyskeDIqu1M6w==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^1.0.2",
+        "@inquirer/core": "^10.3.2",
+        "@inquirer/figures": "^1.0.15",
+        "@inquirer/type": "^3.0.10",
+        "yoctocolors-cjs": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/type": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/@inquirer/type/-/type-3.0.10.tgz",
+      "integrity": "sha512-BvziSRxfz5Ov8ch0z/n3oijRSEcEsHnhggm4xFZe93DHcUCTlutlq9Ox4SVENAfcRD22UQq7T/atg9Wr3k09eA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@oclif/core": {
+      "version": "4.11.2",
+      "resolved": "https://registry.npmjs.org/@oclif/core/-/core-4.11.2.tgz",
+      "integrity": "sha512-LWDalCgy+hYyAkLa9sMIXMXk6ws5RzQhVnkmfXtVIIyEEYigbXQ/9/x+s76p53MiXxNc6SJB7lfwkPF+SdzfMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-escapes": "^4.3.2",
+        "ansis": "^3.17.0",
+        "clean-stack": "^3.0.1",
+        "cli-spinners": "^2.9.2",
+        "debug": "^4.4.3",
+        "ejs": "^3.1.10",
+        "get-package-type": "^0.1.0",
+        "indent-string": "^4.0.0",
+        "is-wsl": "^2.2.0",
+        "lilconfig": "^3.1.3",
+        "minimatch": "^10.2.5",
+        "semver": "^7.8.0",
+        "string-width": "^4.2.3",
+        "supports-color": "^8",
+        "tinyglobby": "^0.2.14",
+        "widest-line": "^3.1.0",
+        "wordwrap": "^1.0.0",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@oclif/plugin-autocomplete": {
+      "version": "3.2.49",
+      "resolved": "https://registry.npmjs.org/@oclif/plugin-autocomplete/-/plugin-autocomplete-3.2.49.tgz",
+      "integrity": "sha512-+rrAZ468bW/B9uVrn6sEnFYepy3M1N/BWht8mHzhFIFCIduPSoE+8MweROxZLOGBZrXGWt0iavuPQmy0eaXRfQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@oclif/core": "^4",
+        "ansis": "^3.16.0",
+        "debug": "^4.4.1",
+        "ejs": "^3.1.10"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@oclif/plugin-help": {
+      "version": "6.2.48",
+      "resolved": "https://registry.npmjs.org/@oclif/plugin-help/-/plugin-help-6.2.48.tgz",
+      "integrity": "sha512-nvGLBtUZUWrHfoAEDRsRZUHKVwptyZ6F+MErdVRLQBo3dja0GCZH8DE33dA7mBux2KOmbxGqop15gyud9HZYhQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@oclif/core": "^4"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@oclif/plugin-not-found": {
+      "version": "3.2.85",
+      "resolved": "https://registry.npmjs.org/@oclif/plugin-not-found/-/plugin-not-found-3.2.85.tgz",
+      "integrity": "sha512-Si18rRKWknlvQ5anmFbQz9oKBae5/l/Npreuf05xdoNWfOV1J97Z7cpzqBlHbldmxCIiDRgmDKuCBBi4XN6ACA==",
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/prompts": "^7.10.1",
+        "@oclif/core": "^4.11.2",
+        "ansis": "^3.17.0",
+        "fast-levenshtein": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "25.7.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.7.0.tgz",
+      "integrity": "sha512-z+pdZyxE+RTQE9AcboAZCb4otwcrvgHD+GlBpPgn0emDVt0ohrTMhAwlr2Wd9nZ+nihhYFxO2pThz3C5qSu2Eg==",
+      "devOptional": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.21.0"
+      }
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.14",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz",
+      "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==",
+      "devOptional": true,
+      "license": "MIT",
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/ansi-escapes": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz",
+      "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==",
+      "license": "MIT",
+      "dependencies": {
+        "type-fest": "^0.21.3"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/ansis": {
+      "version": "3.17.0",
+      "resolved": "https://registry.npmjs.org/ansis/-/ansis-3.17.0.tgz",
+      "integrity": "sha512-0qWUglt9JEqLFr3w1I1pbrChn1grhaiAR2ocX1PP/flRmxgtwTzPFFFnfIlD6aMOLQZgSuCRlidD70lvx8yhzg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/async": {
+      "version": "3.2.6",
+      "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+      "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
+      "license": "MIT"
+    },
+    "node_modules/auto-bind": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/auto-bind/-/auto-bind-5.0.1.tgz",
+      "integrity": "sha512-ooviqdwwgfIfNmDwo94wlshcdzfO64XV0Cg6oDsDYBJfITDz1EngD2z7DkbvCWn+XIMsIqW27sEVF6qcpJrRcg==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "5.0.6",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
+      "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "5.6.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz",
+      "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.17.0 || ^14.13 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/chardet": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/chardet/-/chardet-2.1.1.tgz",
+      "integrity": "sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==",
+      "license": "MIT"
+    },
+    "node_modules/clean-stack": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-3.0.1.tgz",
+      "integrity": "sha512-lR9wNiMRcVQjSB3a7xXGLuz4cr4wJuuXlaAEbRutGowQTmlp7R72/DOgN21e8jdwblMWl9UOJMJXarX94pzKdg==",
+      "license": "MIT",
+      "dependencies": {
+        "escape-string-regexp": "4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/cli-boxes": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/cli-boxes/-/cli-boxes-4.0.1.tgz",
+      "integrity": "sha512-5IOn+jcCEHEraYolBPs/sT4BxYCe2nHg374OPiItB1O96KZFseS2gthU4twyYzeDcFew4DaUM/xwc5BQf08JJw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.20 <19 || >=20.10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/cli-cursor": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-4.0.0.tgz",
+      "integrity": "sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==",
+      "license": "MIT",
+      "dependencies": {
+        "restore-cursor": "^4.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/cli-spinners": {
+      "version": "2.9.2",
+      "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.9.2.tgz",
+      "integrity": "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/cli-truncate": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-6.0.0.tgz",
+      "integrity": "sha512-3+YKIUFsohD9MIoOFPFBldjAlnfCmCDcqe6aYGFqlDTRKg80p4wg35L+j83QQ63iOlKRccEkbn8IuM++HsgEjA==",
+      "license": "MIT",
+      "dependencies": {
+        "slice-ansi": "^9.0.0",
+        "string-width": "^8.2.0"
+      },
+      "engines": {
+        "node": ">=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/cli-truncate/node_modules/ansi-regex": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/cli-truncate/node_modules/string-width": {
+      "version": "8.2.1",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-8.2.1.tgz",
+      "integrity": "sha512-IIaP0g3iy9Cyy18w3M9YcaDudujEAVHKt3a3QJg1+sr/oX96TbaGUubG0hJyCjCBThFH+tFpcIyoUHUn1ogaLA==",
+      "license": "MIT",
+      "dependencies": {
+        "get-east-asian-width": "^1.5.0",
+        "strip-ansi": "^7.1.2"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/cli-truncate/node_modules/strip-ansi": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.2.2"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/cli-width": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-4.1.0.tgz",
+      "integrity": "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/code-excerpt": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/code-excerpt/-/code-excerpt-4.0.0.tgz",
+      "integrity": "sha512-xxodCmBen3iy2i0WtAK8FlFNrRzjUqjRsMfho58xT/wvZU1YTM3fCnRjcy1gJPMepaRlgm/0e6w8SpWHpn3/cA==",
+      "license": "MIT",
+      "dependencies": {
+        "convert-to-spaces": "^2.0.1"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/convert-to-spaces": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/convert-to-spaces/-/convert-to-spaces-2.0.1.tgz",
+      "integrity": "sha512-rcQ1bsQO9799wq24uE5AM2tAILy4gXGIK/njFWcVQkGNZ96edlpY+A7bjwvzjYvLDyzmG1MmMLZhpcsb+klNMQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "devOptional": true,
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/ejs": {
+      "version": "3.1.10",
+      "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz",
+      "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "jake": "^10.8.5"
+      },
+      "bin": {
+        "ejs": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/environment": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz",
+      "integrity": "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/es-toolkit": {
+      "version": "1.46.1",
+      "resolved": "https://registry.npmjs.org/es-toolkit/-/es-toolkit-1.46.1.tgz",
+      "integrity": "sha512-5eNtXOs3tbfxXOj04tjjseeWkRWaoCjdEI+96DgwzZoe6c9juL49pXlzAFTI72aWC9Y8p7168g6XIKjh7k6pyQ==",
+      "license": "MIT",
+      "workspaces": [
+        "docs",
+        "benchmarks"
+      ]
+    },
+    "node_modules/esbuild": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.7.tgz",
+      "integrity": "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.27.7",
+        "@esbuild/android-arm": "0.27.7",
+        "@esbuild/android-arm64": "0.27.7",
+        "@esbuild/android-x64": "0.27.7",
+        "@esbuild/darwin-arm64": "0.27.7",
+        "@esbuild/darwin-x64": "0.27.7",
+        "@esbuild/freebsd-arm64": "0.27.7",
+        "@esbuild/freebsd-x64": "0.27.7",
+        "@esbuild/linux-arm": "0.27.7",
+        "@esbuild/linux-arm64": "0.27.7",
+        "@esbuild/linux-ia32": "0.27.7",
+        "@esbuild/linux-loong64": "0.27.7",
+        "@esbuild/linux-mips64el": "0.27.7",
+        "@esbuild/linux-ppc64": "0.27.7",
+        "@esbuild/linux-riscv64": "0.27.7",
+        "@esbuild/linux-s390x": "0.27.7",
+        "@esbuild/linux-x64": "0.27.7",
+        "@esbuild/netbsd-arm64": "0.27.7",
+        "@esbuild/netbsd-x64": "0.27.7",
+        "@esbuild/openbsd-arm64": "0.27.7",
+        "@esbuild/openbsd-x64": "0.27.7",
+        "@esbuild/openharmony-arm64": "0.27.7",
+        "@esbuild/sunos-x64": "0.27.7",
+        "@esbuild/win32-arm64": "0.27.7",
+        "@esbuild/win32-ia32": "0.27.7",
+        "@esbuild/win32-x64": "0.27.7"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-3.0.0.tgz",
+      "integrity": "sha512-hKKNajm46uNmTlhHSyZkmToAc56uZJwYq7yrciZjqOxnlfQwERDQJmHPUp7m1m9wx8vgOe8IaCKZ5Kv2k1DdCQ==",
+      "license": "MIT",
+      "dependencies": {
+        "fastest-levenshtein": "^1.0.7"
+      }
+    },
+    "node_modules/fastest-levenshtein": {
+      "version": "1.0.16",
+      "resolved": "https://registry.npmjs.org/fastest-levenshtein/-/fastest-levenshtein-1.0.16.tgz",
+      "integrity": "sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4.9.1"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/figures": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/figures/-/figures-6.1.0.tgz",
+      "integrity": "sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==",
+      "license": "MIT",
+      "dependencies": {
+        "is-unicode-supported": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/filelist": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.6.tgz",
+      "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "minimatch": "^5.0.1"
+      }
+    },
+    "node_modules/filelist/node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "license": "MIT"
+    },
+    "node_modules/filelist/node_modules/brace-expansion": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.0.tgz",
+      "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/filelist/node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/get-east-asian-width": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.6.0.tgz",
+      "integrity": "sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/get-package-type": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz",
+      "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
+    "node_modules/get-tsconfig": {
+      "version": "4.14.0",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.14.0.tgz",
+      "integrity": "sha512-yTb+8DXzDREzgvYmh6s9vHsSVCHeC0G3PI5bEXNBHtmshPnO+S5O7qgLEOn0I5QvMy6kpZN8K1NKGyilLb93wA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "resolve-pkg-maps": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
+      "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/indent-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
+      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ink": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/ink/-/ink-7.0.3.tgz",
+      "integrity": "sha512-5kxHkIj9+RuqCU3zyvP4qvYWNOSHP2TW/SHayHGHOmk87KwfVcZwvJGemi9ch+ci2gXUqerK/Eh2DGEDt5q45g==",
+      "license": "MIT",
+      "dependencies": {
+        "@alcalzone/ansi-tokenize": "^0.3.0",
+        "ansi-escapes": "^7.3.0",
+        "ansi-styles": "^6.2.3",
+        "auto-bind": "^5.0.1",
+        "chalk": "^5.6.2",
+        "cli-boxes": "^4.0.1",
+        "cli-cursor": "^4.0.0",
+        "cli-truncate": "^6.0.0",
+        "code-excerpt": "^4.0.0",
+        "es-toolkit": "^1.45.1",
+        "indent-string": "^5.0.0",
+        "is-in-ci": "^2.0.0",
+        "patch-console": "^2.0.0",
+        "react-reconciler": "^0.33.0",
+        "scheduler": "^0.27.0",
+        "signal-exit": "^3.0.7",
+        "slice-ansi": "^9.0.0",
+        "stack-utils": "^2.0.6",
+        "string-width": "^8.2.0",
+        "terminal-size": "^4.0.1",
+        "type-fest": "^5.5.0",
+        "widest-line": "^6.0.0",
+        "wrap-ansi": "^10.0.0",
+        "ws": "^8.20.0",
+        "yoga-layout": "~3.2.1"
+      },
+      "engines": {
+        "node": ">=22"
+      },
+      "peerDependencies": {
+        "@types/react": ">=19.2.0",
+        "react": ">=19.2.0",
+        "react-devtools-core": ">=6.1.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "react-devtools-core": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/ink-spinner": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/ink-spinner/-/ink-spinner-5.0.0.tgz",
+      "integrity": "sha512-EYEasbEjkqLGyPOUc8hBJZNuC5GvXGMLu0w5gdTNskPc7Izc5vO3tdQEYnzvshucyGCBXc86ig0ujXPMWaQCdA==",
+      "license": "MIT",
+      "dependencies": {
+        "cli-spinners": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=14.16"
+      },
+      "peerDependencies": {
+        "ink": ">=4.0.0",
+        "react": ">=18.0.0"
+      }
+    },
+    "node_modules/ink/node_modules/ansi-escapes": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.3.0.tgz",
+      "integrity": "sha512-BvU8nYgGQBxcmMuEeUEmNTvrMVjJNSH7RgW24vXexN4Ven6qCvy4TntnvlnwnMLTVlcRQQdbRY8NKnaIoeWDNg==",
+      "license": "MIT",
+      "dependencies": {
+        "environment": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ink/node_modules/ansi-regex": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
+      "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/ink/node_modules/ansi-styles": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/ink/node_modules/indent-string": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz",
+      "integrity": "sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ink/node_modules/signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+      "license": "ISC"
+    },
+    "node_modules/ink/node_modules/string-width": {
+      "version": "8.2.1",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-8.2.1.tgz",
+      "integrity": "sha512-IIaP0g3iy9Cyy18w3M9YcaDudujEAVHKt3a3QJg1+sr/oX96TbaGUubG0hJyCjCBThFH+tFpcIyoUHUn1ogaLA==",
+      "license": "MIT",
+      "dependencies": {
+        "get-east-asian-width": "^1.5.0",
+        "strip-ansi": "^7.1.2"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ink/node_modules/strip-ansi": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.2.2"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/ink/node_modules/type-fest": {
+      "version": "5.6.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.6.0.tgz",
+      "integrity": "sha512-8ZiHFm91orbSAe2PSAiSVBVko18pbhbiB3U9GglSzF/zCGkR+rxpHx6sEMCUm4kxY4LjDIUGgCfUMtwfZfjfUA==",
+      "license": "(MIT OR CC0-1.0)",
+      "dependencies": {
+        "tagged-tag": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ink/node_modules/widest-line": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-6.0.0.tgz",
+      "integrity": "sha512-U89AsyEeAsyoF0zVJBkG9zBgekjgjK7yk9sje3F4IQpXBJ10TF6ByLlIfjMhcmHMJgHZI4KHt4rdNfktzxIAMA==",
+      "license": "MIT",
+      "dependencies": {
+        "string-width": "^8.1.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ink/node_modules/wrap-ansi": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-10.0.0.tgz",
+      "integrity": "sha512-SGcvg80f0wUy2/fXES19feHMz8E0JoXv2uNgHOu4Dgi2OrCy1lqwFYEJz1BLbDI0exjPMe/ZdzZ/YpGECBG/aQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.2.3",
+        "string-width": "^8.2.0",
+        "strip-ansi": "^7.1.2"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/is-docker": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz",
+      "integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==",
+      "license": "MIT",
+      "bin": {
+        "is-docker": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-in-ci": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-in-ci/-/is-in-ci-2.0.0.tgz",
+      "integrity": "sha512-cFeerHriAnhrQSbpAxL37W1wcJKUUX07HyLWZCW1URJT/ra3GyUTzBgUnh24TMVfNTV2Hij2HLxkPHFZfOZy5w==",
+      "license": "MIT",
+      "bin": {
+        "is-in-ci": "cli.js"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-unicode-supported": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz",
+      "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-wsl": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz",
+      "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==",
+      "license": "MIT",
+      "dependencies": {
+        "is-docker": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/jake": {
+      "version": "10.9.4",
+      "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz",
+      "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "async": "^3.2.6",
+        "filelist": "^1.0.4",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "jake": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/lilconfig": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
+      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antonk52"
+      }
+    },
+    "node_modules/mimic-fn": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
+      "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "10.2.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
+      "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "brace-expansion": "^5.0.5"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/mute-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-2.0.0.tgz",
+      "integrity": "sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==",
+      "license": "ISC",
+      "engines": {
+        "node": "^18.17.0 || >=20.5.0"
+      }
+    },
+    "node_modules/onetime": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
+      "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
+      "license": "MIT",
+      "dependencies": {
+        "mimic-fn": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/patch-console": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/patch-console/-/patch-console-2.0.0.tgz",
+      "integrity": "sha512-0YNdUceMdaQwoKce1gatDScmMo5pu/tfABfnzEqeG0gtTmd7mh/WcwgUjtAeOU7N8nFFlbQBnFK2gXW5fGvmMA==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.2.6",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.6.tgz",
+      "integrity": "sha512-sfWGGfavi0xr8Pg0sVsyHMAOziVYKgPLNrS7ig+ivMNb3wbCBw3KxtflsGBAwD3gYQlE/AEZsTLgToRrSCjb0Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-reconciler": {
+      "version": "0.33.0",
+      "resolved": "https://registry.npmjs.org/react-reconciler/-/react-reconciler-0.33.0.tgz",
+      "integrity": "sha512-KetWRytFv1epdpJc3J4G75I4WrplZE5jOL7Yq0p34+OVOKF4Se7WrdIdVC45XsSSmUTlht2FM/fM1FZb1mfQeA==",
+      "license": "MIT",
+      "dependencies": {
+        "scheduler": "^0.27.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "peerDependencies": {
+        "react": "^19.2.0"
+      }
+    },
+    "node_modules/resolve-pkg-maps": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+      }
+    },
+    "node_modules/restore-cursor": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-4.0.0.tgz",
+      "integrity": "sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==",
+      "license": "MIT",
+      "dependencies": {
+        "onetime": "^5.1.0",
+        "signal-exit": "^3.0.2"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/restore-cursor/node_modules/signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+      "license": "ISC"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "7.8.0",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.0.tgz",
+      "integrity": "sha512-AcM7dV/5ul4EekoQ29Agm5vri8JNqRyj39o0qpX6vDF2GZrtutZl5RwgD1XnZjiTAfncsJhMI48QQH3sN87YNA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/slice-ansi": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-9.0.0.tgz",
+      "integrity": "sha512-SO/3iYL5S3W57LLEniscOGPZgOqZUPCx6d3dB+52B80yJ0XstzsC/eV8gnA4tM3MHDrKz+OCFSLNjswdSC+/bA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.2.3",
+        "is-fullwidth-code-point": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=22"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/slice-ansi?sponsor=1"
+      }
+    },
+    "node_modules/slice-ansi/node_modules/ansi-styles": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/slice-ansi/node_modules/is-fullwidth-code-point": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.1.0.tgz",
+      "integrity": "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "get-east-asian-width": "^1.3.1"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/stack-utils": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz",
+      "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==",
+      "license": "MIT",
+      "dependencies": {
+        "escape-string-regexp": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/stack-utils/node_modules/escape-string-regexp": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz",
+      "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "8.1.1",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
+      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
+      }
+    },
+    "node_modules/tagged-tag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/tagged-tag/-/tagged-tag-1.0.0.tgz",
+      "integrity": "sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/terminal-size": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/terminal-size/-/terminal-size-4.0.1.tgz",
+      "integrity": "sha512-avMLDQpUI9I5XFrklECw1ZEUPJhqzcwSWsyyI8blhRLT+8N1jLJWLWWYQpB2q2xthq8xDvjZPISVh53T/+CLYQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.16",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz",
+      "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==",
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tsx": {
+      "version": "4.21.0",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz",
+      "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "~0.27.0",
+        "get-tsconfig": "^4.7.5"
+      },
+      "bin": {
+        "tsx": "dist/cli.mjs"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      }
+    },
+    "node_modules/type-fest": {
+      "version": "0.21.3",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz",
+      "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==",
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
+      "integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.21.0.tgz",
+      "integrity": "sha512-w9IMgQrz4O0YN1LtB7K5P63vhlIOvC7opSmouCJ+ZywlPAlO9gIkJ+otk6LvGpAs2wg4econaCz3TvQ9xPoyuQ==",
+      "devOptional": true,
+      "license": "MIT"
+    },
+    "node_modules/widest-line": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-3.1.0.tgz",
+      "integrity": "sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==",
+      "license": "MIT",
+      "dependencies": {
+        "string-width": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/wordwrap": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz",
+      "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==",
+      "license": "MIT"
+    },
+    "node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.20.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.1.tgz",
+      "integrity": "sha512-It4dO0K5v//JtTXuPkfEOaI3uUN87iYPnqo/ZzqCoG3g8uhA66QUMs/SrM0YK7/NAu+r4LMh/9dq2A7k+rHs+w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/yoctocolors-cjs": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/yoctocolors-cjs/-/yoctocolors-cjs-2.1.3.tgz",
+      "integrity": "sha512-U/PBtDf35ff0D8X8D0jfdzHYEPFxAI7jJlxZXwCSez5M3190m+QobIfh+sWDWSHMCWWJN2AWamkegn6vr6YBTw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/yoga-layout": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/yoga-layout/-/yoga-layout-3.2.1.tgz",
+      "integrity": "sha512-0LPOt3AxKqMdFBZA3HBAt/t/8vIKq7VaQYbuA8WxCgung+p9TVyKRYdpvCb80HcdTN2NkbIKbhNwKUfm3tQywQ==",
+      "license": "MIT"
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..fafb400
--- /dev/null
+++ b/package.json
@@ -0,0 +1,100 @@
+{
+  "name": "beeper-cli",
+  "version": "0.0.0",
+  "description": "Beeper CLI",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "beeper": "./bin/run.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "check:api-copy": "npm run build && node scripts/check-api-copy.mjs",
+    "check:readme": "npm run build && node scripts/generate-readme.mjs --check",
+    "dev": "node --import tsx ./bin/dev.js",
+    "e2e:staging": "npm run build && node test/e2e-staging.mjs",
+    "pack:homebrew": "npm run build && node scripts/build-homebrew-archive.mjs",
+    "readme": "npm run build && node scripts/generate-readme.mjs",
+    "test": "npm run build && node scripts/generate-readme.mjs --check && node scripts/check-api-copy.mjs && node ./test/cli-smoke.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "oclif": {
+    "additionalHelpFlags": [
+      "-h"
+    ],
+    "commands": {
+      "strategy": "pattern",
+      "target": "./dist/commands",
+      "globPatterns": [
+        "**/*.js"
+      ]
+    },
+    "bin": "beeper",
+    "dirname": "beeper",
+    "flexibleTaxonomy": true,
+    "helpOptions": {
+      "maxWidth": 100
+    },
+    "plugins": [
+      "@oclif/plugin-help",
+      "@oclif/plugin-autocomplete",
+      "@oclif/plugin-not-found"
+    ],
+    "topicSeparator": " ",
+    "topics": {
+      "api": {
+        "description": "Call raw Desktop API endpoints."
+      },
+      "app": {
+        "description": "Manage app login and encrypted messaging setup."
+      },
+      "accounts": {
+        "description": "Manage Beeper accounts."
+      },
+      "assets": {
+        "description": "Upload and download message assets."
+      },
+      "auth": {
+        "description": "Authenticate with local Beeper Desktop."
+      },
+      "chat": {
+        "description": "Open and inspect one chat."
+      },
+      "chats": {
+        "description": "List and search chats."
+      },
+      "config": {
+        "description": "Manage local CLI configuration."
+      },
+      "contacts": {
+        "description": "Search contacts across accounts."
+      },
+      "messages": {
+        "description": "List and search chat messages."
+      }
+    }
+  },
+  "dependencies": {
+    "@beeper/desktop-api": "^5.0.0",
+    "@oclif/core": "^4.11.2",
+    "@oclif/plugin-autocomplete": "^3.2.49",
+    "@oclif/plugin-help": "^6.2.48",
+    "@oclif/plugin-not-found": "^3.2.85",
+    "figures": "^6.1.0",
+    "ink": "^7.0.3",
+    "ink-spinner": "^5.0.0",
+    "react": "^19.2.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.7.0",
+    "@types/react": "^19.2.14",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
+  }
+}
diff --git a/pkg/cmd/account.go b/pkg/cmd/account.go
deleted file mode 100644
index 6ee1774..0000000
--- a/pkg/cmd/account.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/beeper/desktop-api-cli/internal/apiquery"
-	"github.com/beeper/desktop-api-go"
-	"github.com/beeper/desktop-api-go/option"
-	"github.com/tidwall/gjson"
-	"github.com/urfave/cli/v3"
-)
-
-var accountsList = cli.Command{
-	Name:            "list",
-	Usage:           "Lists chat accounts across networks (WhatsApp, Telegram, Twitter/X, etc.)\nactively connected to this Beeper Desktop instance",
-	Suggest:         true,
-	Flags:           []cli.Flag{},
-	Action:          handleAccountsList,
-	HideHelpCommand: true,
-}
-
-func handleAccountsList(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Accounts.List(ctx, options...)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "accounts list", obj, format, transform)
-}
diff --git a/pkg/cmd/account_test.go b/pkg/cmd/account_test.go
deleted file mode 100644
index cc8844f..0000000
--- a/pkg/cmd/account_test.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"testing"
-
-	"github.com/beeper/desktop-api-cli/internal/mocktest"
-)
-
-func TestAccountsList(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"accounts", "list",
-		)
-	})
-}
diff --git a/pkg/cmd/accountcontact.go b/pkg/cmd/accountcontact.go
deleted file mode 100644
index 76cc862..0000000
--- a/pkg/cmd/accountcontact.go
+++ /dev/null
@@ -1,174 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/beeper/desktop-api-cli/internal/apiquery"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-	"github.com/beeper/desktop-api-go"
-	"github.com/beeper/desktop-api-go/option"
-	"github.com/tidwall/gjson"
-	"github.com/urfave/cli/v3"
-)
-
-var accountsContactsList = cli.Command{
-	Name:    "list",
-	Usage:   "List merged contacts for a specific account with cursor-based pagination.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "account-id",
-			Usage:    "Account ID this resource belongs to.",
-			Required: true,
-		},
-		&requestflag.Flag[string]{
-			Name:      "cursor",
-			Usage:     "Opaque pagination cursor; do not inspect. Use together with 'direction'.",
-			QueryPath: "cursor",
-		},
-		&requestflag.Flag[string]{
-			Name:      "direction",
-			Usage:     "Pagination direction used with 'cursor': 'before' fetches older results, 'after' fetches newer results. Defaults to 'before' when only 'cursor' is provided.",
-			QueryPath: "direction",
-		},
-		&requestflag.Flag[int64]{
-			Name:      "limit",
-			Usage:     "Maximum contacts to return per page.",
-			Default:   50,
-			QueryPath: "limit",
-		},
-		&requestflag.Flag[string]{
-			Name:      "query",
-			Usage:     "Optional search query for blended contact lookup.",
-			QueryPath: "query",
-		},
-		&requestflag.Flag[int64]{
-			Name:  "max-items",
-			Usage: "The maximum number of items to return (use -1 for unlimited).",
-		},
-	},
-	Action:          handleAccountsContactsList,
-	HideHelpCommand: true,
-}
-
-var accountsContactsSearch = cli.Command{
-	Name:    "search",
-	Usage:   "Search contacts on a specific account using merged account contacts, network\nsearch, and exact identifier lookup.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "account-id",
-			Usage:    "Account ID this resource belongs to.",
-			Required: true,
-		},
-		&requestflag.Flag[string]{
-			Name:      "query",
-			Usage:     "Text to search users by. Network-specific behavior.",
-			Required:  true,
-			QueryPath: "query",
-		},
-	},
-	Action:          handleAccountsContactsSearch,
-	HideHelpCommand: true,
-}
-
-func handleAccountsContactsList(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-	if !cmd.IsSet("account-id") && len(unusedArgs) > 0 {
-		cmd.Set("account-id", unusedArgs[0])
-		unusedArgs = unusedArgs[1:]
-	}
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.AccountContactListParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	if format == "raw" {
-		var res []byte
-		options = append(options, option.WithResponseBodyInto(&res))
-		_, err = client.Accounts.Contacts.List(
-			ctx,
-			cmd.Value("account-id").(string),
-			params,
-			options...,
-		)
-		if err != nil {
-			return err
-		}
-		obj := gjson.ParseBytes(res)
-		return ShowJSON(os.Stdout, "accounts:contacts list", obj, format, transform)
-	} else {
-		iter := client.Accounts.Contacts.ListAutoPaging(
-			ctx,
-			cmd.Value("account-id").(string),
-			params,
-			options...,
-		)
-		maxItems := int64(-1)
-		if cmd.IsSet("max-items") {
-			maxItems = cmd.Value("max-items").(int64)
-		}
-		return ShowJSONIterator(os.Stdout, "accounts:contacts list", iter, format, transform, maxItems)
-	}
-}
-
-func handleAccountsContactsSearch(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-	if !cmd.IsSet("account-id") && len(unusedArgs) > 0 {
-		cmd.Set("account-id", unusedArgs[0])
-		unusedArgs = unusedArgs[1:]
-	}
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.AccountContactSearchParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Accounts.Contacts.Search(
-		ctx,
-		cmd.Value("account-id").(string),
-		params,
-		options...,
-	)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "accounts:contacts search", obj, format, transform)
-}
diff --git a/pkg/cmd/accountcontact_test.go b/pkg/cmd/accountcontact_test.go
deleted file mode 100644
index 36d7908..0000000
--- a/pkg/cmd/accountcontact_test.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"testing"
-
-	"github.com/beeper/desktop-api-cli/internal/mocktest"
-)
-
-func TestAccountsContactsList(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"accounts:contacts", "list",
-			"--max-items", "10",
-			"--account-id", "accountID",
-			"--cursor", "1725489123456|c29tZUltc2dQYWdl",
-			"--direction", "before",
-			"--limit", "1",
-			"--query", "x",
-		)
-	})
-}
-
-func TestAccountsContactsSearch(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"accounts:contacts", "search",
-			"--account-id", "accountID",
-			"--query", "x",
-		)
-	})
-}
diff --git a/pkg/cmd/asset.go b/pkg/cmd/asset.go
deleted file mode 100644
index d7fc779..0000000
--- a/pkg/cmd/asset.go
+++ /dev/null
@@ -1,226 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/beeper/desktop-api-cli/internal/apiquery"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-	"github.com/beeper/desktop-api-go"
-	"github.com/beeper/desktop-api-go/option"
-	"github.com/tidwall/gjson"
-	"github.com/urfave/cli/v3"
-)
-
-var assetsDownload = cli.Command{
-	Name:    "download",
-	Usage:   "Download a Matrix asset using its mxc:// or localmxc:// URL to the device\nrunning Beeper Desktop and return the local file URL.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "url",
-			Usage:    "Matrix content URL (mxc:// or localmxc://) for the asset to download.",
-			Required: true,
-			BodyPath: "url",
-		},
-	},
-	Action:          handleAssetsDownload,
-	HideHelpCommand: true,
-}
-
-var assetsServe = cli.Command{
-	Name:    "serve",
-	Usage:   "Stream a file given an mxc://, localmxc://, or file:// URL. Downloads first if\nnot cached. Supports Range requests for seeking in large files.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:      "url",
-			Usage:     "Asset URL to serve. Accepts mxc://, localmxc://, or file:// URLs.",
-			Required:  true,
-			QueryPath: "url",
-		},
-	},
-	Action:          handleAssetsServe,
-	HideHelpCommand: true,
-}
-
-var assetsUpload = cli.Command{
-	Name:    "upload",
-	Usage:   "Upload a file to a temporary location using multipart/form-data. Returns an\nuploadID that can be referenced when sending messages with attachments.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "file",
-			Usage:    "The file to upload (max 500 MB).",
-			Required: true,
-			BodyPath: "file",
-		},
-		&requestflag.Flag[string]{
-			Name:     "file-name",
-			Usage:    "Original filename. Defaults to the uploaded file name if omitted",
-			BodyPath: "fileName",
-		},
-		&requestflag.Flag[string]{
-			Name:     "mime-type",
-			Usage:    "MIME type. Auto-detected from magic bytes if omitted",
-			BodyPath: "mimeType",
-		},
-	},
-	Action:          handleAssetsUpload,
-	HideHelpCommand: true,
-}
-
-var assetsUploadBase64 = cli.Command{
-	Name:    "upload-base64",
-	Usage:   "Upload a file using a JSON body with base64-encoded content. Returns an uploadID\nthat can be referenced when sending messages with attachments. Alternative to\nthe multipart upload endpoint.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "content",
-			Usage:    "Base64-encoded file content (max ~500MB decoded)",
-			Required: true,
-			BodyPath: "content",
-		},
-		&requestflag.Flag[string]{
-			Name:     "file-name",
-			Usage:    "Original filename. Generated if omitted",
-			BodyPath: "fileName",
-		},
-		&requestflag.Flag[string]{
-			Name:     "mime-type",
-			Usage:    "MIME type. Auto-detected from magic bytes if omitted",
-			BodyPath: "mimeType",
-		},
-	},
-	Action:          handleAssetsUploadBase64,
-	HideHelpCommand: true,
-}
-
-func handleAssetsDownload(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.AssetDownloadParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		ApplicationJSON,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Assets.Download(ctx, params, options...)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "assets download", obj, format, transform)
-}
-
-func handleAssetsServe(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.AssetServeParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	return client.Assets.Serve(ctx, params, options...)
-}
-
-func handleAssetsUpload(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.AssetUploadParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		MultipartFormEncoded,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Assets.Upload(ctx, params, options...)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "assets upload", obj, format, transform)
-}
-
-func handleAssetsUploadBase64(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.AssetUploadBase64Params{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		ApplicationJSON,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Assets.UploadBase64(ctx, params, options...)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "assets upload-base64", obj, format, transform)
-}
diff --git a/pkg/cmd/asset_test.go b/pkg/cmd/asset_test.go
deleted file mode 100644
index 2ce574c..0000000
--- a/pkg/cmd/asset_test.go
+++ /dev/null
@@ -1,93 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"testing"
-
-	"github.com/beeper/desktop-api-cli/internal/mocktest"
-)
-
-func TestAssetsDownload(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"assets", "download",
-			"--url", "mxc://example.org/Q4x9CqGz1pB3Oa6XgJ",
-		)
-	})
-
-	t.Run("piping data", func(t *testing.T) {
-		// Test piping YAML data over stdin
-		pipeData := []byte("url: mxc://example.org/Q4x9CqGz1pB3Oa6XgJ")
-		mocktest.TestRunMockTestWithPipeAndFlags(
-			t, pipeData,
-			"--access-token", "string",
-			"assets", "download",
-		)
-	})
-}
-
-func TestAssetsServe(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"assets", "serve",
-			"--url", "x",
-		)
-	})
-}
-
-func TestAssetsUpload(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"assets", "upload",
-			"--file", "Example data",
-			"--file-name", "fileName",
-			"--mime-type", "mimeType",
-		)
-	})
-
-	t.Run("piping data", func(t *testing.T) {
-		// Test piping YAML data over stdin
-		pipeData := []byte("" +
-			"file: Example data\n" +
-			"fileName: fileName\n" +
-			"mimeType: mimeType\n")
-		mocktest.TestRunMockTestWithPipeAndFlags(
-			t, pipeData,
-			"--access-token", "string",
-			"assets", "upload",
-		)
-	})
-}
-
-func TestAssetsUploadBase64(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"assets", "upload-base64",
-			"--content", "x",
-			"--file-name", "fileName",
-			"--mime-type", "mimeType",
-		)
-	})
-
-	t.Run("piping data", func(t *testing.T) {
-		// Test piping YAML data over stdin
-		pipeData := []byte("" +
-			"content: x\n" +
-			"fileName: fileName\n" +
-			"mimeType: mimeType\n")
-		mocktest.TestRunMockTestWithPipeAndFlags(
-			t, pipeData,
-			"--access-token", "string",
-			"assets", "upload-base64",
-		)
-	})
-}
diff --git a/pkg/cmd/beeperdesktopapi.go b/pkg/cmd/beeperdesktopapi.go
deleted file mode 100644
index bbef6b7..0000000
--- a/pkg/cmd/beeperdesktopapi.go
+++ /dev/null
@@ -1,130 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/beeper/desktop-api-cli/internal/apiquery"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-	"github.com/beeper/desktop-api-go"
-	"github.com/beeper/desktop-api-go/option"
-	"github.com/tidwall/gjson"
-	"github.com/urfave/cli/v3"
-)
-
-var focus = cli.Command{
-	Name:    "focus",
-	Usage:   "Focus Beeper Desktop and optionally navigate to a specific chat, message, or\npre-fill draft text and attachment.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "chat-id",
-			Usage:    "Optional Beeper chat ID (or local chat ID) to focus after opening the app. If omitted, only opens/focuses the app.",
-			BodyPath: "chatID",
-		},
-		&requestflag.Flag[string]{
-			Name:     "draft-attachment-path",
-			Usage:    "Optional draft attachment path to populate in the message input field.",
-			BodyPath: "draftAttachmentPath",
-		},
-		&requestflag.Flag[string]{
-			Name:     "draft-text",
-			Usage:    "Optional draft text to populate in the message input field.",
-			BodyPath: "draftText",
-		},
-		&requestflag.Flag[string]{
-			Name:     "message-id",
-			Usage:    "Optional message ID. Jumps to that message in the chat when opening.",
-			BodyPath: "messageID",
-		},
-	},
-	Action:          handleFocus,
-	HideHelpCommand: true,
-}
-
-var search = cli.Command{
-	Name:    "search",
-	Usage:   "Returns matching chats, participant name matches in groups, and the first page\nof messages in one call. Paginate messages via search-messages. Paginate chats\nvia search-chats.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:      "query",
-			Usage:     "User-typed search text. Literal word matching (non-semantic).",
-			Required:  true,
-			QueryPath: "query",
-		},
-	},
-	Action:          handleSearch,
-	HideHelpCommand: true,
-}
-
-func handleFocus(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.FocusParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		ApplicationJSON,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Focus(ctx, params, options...)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "focus", obj, format, transform)
-}
-
-func handleSearch(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.SearchParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Search(ctx, params, options...)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "search", obj, format, transform)
-}
diff --git a/pkg/cmd/beeperdesktopapi_test.go b/pkg/cmd/beeperdesktopapi_test.go
deleted file mode 100644
index f07d043..0000000
--- a/pkg/cmd/beeperdesktopapi_test.go
+++ /dev/null
@@ -1,48 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"testing"
-
-	"github.com/beeper/desktop-api-cli/internal/mocktest"
-)
-
-func TestFocus(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"focus",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--draft-attachment-path", "draftAttachmentPath",
-			"--draft-text", "draftText",
-			"--message-id", "messageID",
-		)
-	})
-
-	t.Run("piping data", func(t *testing.T) {
-		// Test piping YAML data over stdin
-		pipeData := []byte("" +
-			"chatID: '!NCdzlIaMjZUmvmvyHU:beeper.com'\n" +
-			"draftAttachmentPath: draftAttachmentPath\n" +
-			"draftText: draftText\n" +
-			"messageID: messageID\n")
-		mocktest.TestRunMockTestWithPipeAndFlags(
-			t, pipeData,
-			"--access-token", "string",
-			"focus",
-		)
-	})
-}
-
-func TestSearch(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"search",
-			"--query", "x",
-		)
-	})
-}
diff --git a/pkg/cmd/chat.go b/pkg/cmd/chat.go
deleted file mode 100644
index 41a766b..0000000
--- a/pkg/cmd/chat.go
+++ /dev/null
@@ -1,437 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/beeper/desktop-api-cli/internal/apiquery"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-	"github.com/beeper/desktop-api-go"
-	"github.com/beeper/desktop-api-go/option"
-	"github.com/tidwall/gjson"
-	"github.com/urfave/cli/v3"
-)
-
-var chatsCreate = requestflag.WithInnerFlags(cli.Command{
-	Name:    "create",
-	Usage:   "Create a single/group chat (mode='create') or start a direct chat from merged\nuser data (mode='start').",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "account-id",
-			Usage:    "Account to create or start the chat on.",
-			Required: true,
-			BodyPath: "accountID",
-		},
-		&requestflag.Flag[bool]{
-			Name:     "allow-invite",
-			Usage:    "Whether invite-based DM creation is allowed when required by the platform. Used for mode='start'.",
-			Default:  true,
-			BodyPath: "allowInvite",
-		},
-		&requestflag.Flag[string]{
-			Name:     "message-text",
-			Usage:    "Optional first message content if the platform requires it to create the chat.",
-			BodyPath: "messageText",
-		},
-		&requestflag.Flag[string]{
-			Name:     "mode",
-			Usage:    "Operation mode. Defaults to 'create' when omitted.",
-			BodyPath: "mode",
-		},
-		&requestflag.Flag[[]string]{
-			Name:     "participant-id",
-			Usage:    "Required when mode='create'. User IDs to include in the new chat.",
-			BodyPath: "participantIDs",
-		},
-		&requestflag.Flag[string]{
-			Name:     "title",
-			Usage:    "Optional title for group chats when mode='create'; ignored for single chats on most platforms.",
-			BodyPath: "title",
-		},
-		&requestflag.Flag[string]{
-			Name:     "type",
-			Usage:    "Required when mode='create'. 'single' requires exactly one participantID; 'group' supports multiple participants and optional title.",
-			BodyPath: "type",
-		},
-		&requestflag.Flag[map[string]any]{
-			Name:     "user",
-			Usage:    "Required when mode='start'. Merged user-like contact payload used to resolve the best identifier.",
-			BodyPath: "user",
-		},
-	},
-	Action:          handleChatsCreate,
-	HideHelpCommand: true,
-}, map[string][]requestflag.HasOuterFlag{
-	"user": {
-		&requestflag.InnerFlag[string]{
-			Name:       "user.id",
-			Usage:      "Known user ID when available.",
-			InnerField: "id",
-		},
-		&requestflag.InnerFlag[string]{
-			Name:       "user.email",
-			Usage:      "Email candidate.",
-			InnerField: "email",
-		},
-		&requestflag.InnerFlag[string]{
-			Name:       "user.full-name",
-			Usage:      "Display name hint used for ranking only.",
-			InnerField: "fullName",
-		},
-		&requestflag.InnerFlag[string]{
-			Name:       "user.phone-number",
-			Usage:      "Phone number candidate (E.164 preferred).",
-			InnerField: "phoneNumber",
-		},
-		&requestflag.InnerFlag[string]{
-			Name:       "user.username",
-			Usage:      "Username/handle candidate.",
-			InnerField: "username",
-		},
-	},
-})
-
-var chatsRetrieve = cli.Command{
-	Name:    "retrieve",
-	Usage:   "Retrieve chat details including metadata, participants, and latest message",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "chat-id",
-			Usage:    "Unique identifier of the chat.",
-			Required: true,
-		},
-		&requestflag.Flag[any]{
-			Name:      "max-participant-count",
-			Usage:     "Maximum number of participants to return. Use -1 for all; otherwise 0–500. Defaults to all (-1).",
-			Default:   -1,
-			QueryPath: "maxParticipantCount",
-		},
-	},
-	Action:          handleChatsRetrieve,
-	HideHelpCommand: true,
-}
-
-var chatsList = cli.Command{
-	Name:    "list",
-	Usage:   "List all chats sorted by last activity (most recent first). Combines all\naccounts into a single paginated list.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[[]string]{
-			Name:      "account-id",
-			Usage:     "Limit to specific account IDs. If omitted, fetches from all accounts.",
-			QueryPath: "accountIDs",
-		},
-		&requestflag.Flag[string]{
-			Name:      "cursor",
-			Usage:     "Opaque pagination cursor; do not inspect. Use together with 'direction'.",
-			QueryPath: "cursor",
-		},
-		&requestflag.Flag[string]{
-			Name:      "direction",
-			Usage:     "Pagination direction used with 'cursor': 'before' fetches older results, 'after' fetches newer results. Defaults to 'before' when only 'cursor' is provided.",
-			QueryPath: "direction",
-		},
-		&requestflag.Flag[int64]{
-			Name:  "max-items",
-			Usage: "The maximum number of items to return (use -1 for unlimited).",
-		},
-	},
-	Action:          handleChatsList,
-	HideHelpCommand: true,
-}
-
-var chatsArchive = cli.Command{
-	Name:    "archive",
-	Usage:   "Archive or unarchive a chat. Set archived=true to move to archive,\narchived=false to move back to inbox",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "chat-id",
-			Usage:    "Unique identifier of the chat.",
-			Required: true,
-		},
-		&requestflag.Flag[bool]{
-			Name:     "archived",
-			Usage:    "True to archive, false to unarchive",
-			Default:  true,
-			BodyPath: "archived",
-		},
-	},
-	Action:          handleChatsArchive,
-	HideHelpCommand: true,
-}
-
-var chatsSearch = cli.Command{
-	Name:    "search",
-	Usage:   "Search chats by title/network or participants using Beeper Desktop's renderer\nalgorithm.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[[]string]{
-			Name:      "account-id",
-			Usage:     "Provide an array of account IDs to filter chats from specific messaging accounts only",
-			QueryPath: "accountIDs",
-		},
-		&requestflag.Flag[string]{
-			Name:      "cursor",
-			Usage:     "Opaque pagination cursor; do not inspect. Use together with 'direction'.",
-			QueryPath: "cursor",
-		},
-		&requestflag.Flag[string]{
-			Name:      "direction",
-			Usage:     "Pagination direction used with 'cursor': 'before' fetches older results, 'after' fetches newer results. Defaults to 'before' when only 'cursor' is provided.",
-			QueryPath: "direction",
-		},
-		&requestflag.Flag[string]{
-			Name:      "inbox",
-			Usage:     `Filter by inbox type: "primary" (non-archived, non-low-priority), "low-priority", or "archive". If not specified, shows all chats.`,
-			QueryPath: "inbox",
-		},
-		&requestflag.Flag[any]{
-			Name:      "include-muted",
-			Usage:     "Include chats marked as Muted by the user, which are usually less important. Default: true. Set to false if the user wants a more refined search.",
-			Default:   true,
-			QueryPath: "includeMuted",
-		},
-		&requestflag.Flag[any]{
-			Name:      "last-activity-after",
-			Usage:     "Provide an ISO datetime string to only retrieve chats with last activity after this time",
-			QueryPath: "lastActivityAfter",
-		},
-		&requestflag.Flag[any]{
-			Name:      "last-activity-before",
-			Usage:     "Provide an ISO datetime string to only retrieve chats with last activity before this time",
-			QueryPath: "lastActivityBefore",
-		},
-		&requestflag.Flag[int64]{
-			Name:      "limit",
-			Usage:     "Set the maximum number of chats to retrieve. Valid range: 1-200, default is 50",
-			Default:   50,
-			QueryPath: "limit",
-		},
-		&requestflag.Flag[string]{
-			Name:      "query",
-			Usage:     `Literal token search (non-semantic). Use single words users type (e.g., "dinner"). When multiple words provided, ALL must match. Case-insensitive.`,
-			QueryPath: "query",
-		},
-		&requestflag.Flag[string]{
-			Name:      "scope",
-			Usage:     "Search scope: 'titles' matches title + network; 'participants' matches participant names.",
-			Default:   "titles",
-			QueryPath: "scope",
-		},
-		&requestflag.Flag[string]{
-			Name:      "type",
-			Usage:     `Specify the type of chats to retrieve: use "single" for direct messages, "group" for group chats, or "any" to get all types`,
-			Default:   "any",
-			QueryPath: "type",
-		},
-		&requestflag.Flag[any]{
-			Name:      "unread-only",
-			Usage:     "Set to true to only retrieve chats that have unread messages",
-			QueryPath: "unreadOnly",
-		},
-		&requestflag.Flag[int64]{
-			Name:  "max-items",
-			Usage: "The maximum number of items to return (use -1 for unlimited).",
-		},
-	},
-	Action:          handleChatsSearch,
-	HideHelpCommand: true,
-}
-
-func handleChatsCreate(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.ChatNewParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		ApplicationJSON,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Chats.New(ctx, params, options...)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "chats create", obj, format, transform)
-}
-
-func handleChatsRetrieve(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-	if !cmd.IsSet("chat-id") && len(unusedArgs) > 0 {
-		cmd.Set("chat-id", unusedArgs[0])
-		unusedArgs = unusedArgs[1:]
-	}
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.ChatGetParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Chats.Get(
-		ctx,
-		cmd.Value("chat-id").(string),
-		params,
-		options...,
-	)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "chats retrieve", obj, format, transform)
-}
-
-func handleChatsList(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.ChatListParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	if format == "raw" {
-		var res []byte
-		options = append(options, option.WithResponseBodyInto(&res))
-		_, err = client.Chats.List(ctx, params, options...)
-		if err != nil {
-			return err
-		}
-		obj := gjson.ParseBytes(res)
-		return ShowJSON(os.Stdout, "chats list", obj, format, transform)
-	} else {
-		iter := client.Chats.ListAutoPaging(ctx, params, options...)
-		maxItems := int64(-1)
-		if cmd.IsSet("max-items") {
-			maxItems = cmd.Value("max-items").(int64)
-		}
-		return ShowJSONIterator(os.Stdout, "chats list", iter, format, transform, maxItems)
-	}
-}
-
-func handleChatsArchive(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-	if !cmd.IsSet("chat-id") && len(unusedArgs) > 0 {
-		cmd.Set("chat-id", unusedArgs[0])
-		unusedArgs = unusedArgs[1:]
-	}
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.ChatArchiveParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		ApplicationJSON,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	return client.Chats.Archive(
-		ctx,
-		cmd.Value("chat-id").(string),
-		params,
-		options...,
-	)
-}
-
-func handleChatsSearch(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.ChatSearchParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	if format == "raw" {
-		var res []byte
-		options = append(options, option.WithResponseBodyInto(&res))
-		_, err = client.Chats.Search(ctx, params, options...)
-		if err != nil {
-			return err
-		}
-		obj := gjson.ParseBytes(res)
-		return ShowJSON(os.Stdout, "chats search", obj, format, transform)
-	} else {
-		iter := client.Chats.SearchAutoPaging(ctx, params, options...)
-		maxItems := int64(-1)
-		if cmd.IsSet("max-items") {
-			maxItems = cmd.Value("max-items").(int64)
-		}
-		return ShowJSONIterator(os.Stdout, "chats search", iter, format, transform, maxItems)
-	}
-}
diff --git a/pkg/cmd/chat_test.go b/pkg/cmd/chat_test.go
deleted file mode 100644
index ff041f7..0000000
--- a/pkg/cmd/chat_test.go
+++ /dev/null
@@ -1,150 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"testing"
-
-	"github.com/beeper/desktop-api-cli/internal/mocktest"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-)
-
-func TestChatsCreate(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"chats", "create",
-			"--account-id", "accountID",
-			"--allow-invite=true",
-			"--message-text", "messageText",
-			"--mode", "create",
-			"--participant-id", "string",
-			"--title", "title",
-			"--type", "single",
-			"--user", "{id: id, email: email, fullName: fullName, phoneNumber: phoneNumber, username: username}",
-		)
-	})
-
-	t.Run("inner flags", func(t *testing.T) {
-		// Check that inner flags have been set up correctly
-		requestflag.CheckInnerFlags(chatsCreate)
-
-		// Alternative argument passing style using inner flags
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"chats", "create",
-			"--account-id", "accountID",
-			"--allow-invite=true",
-			"--message-text", "messageText",
-			"--mode", "create",
-			"--participant-id", "string",
-			"--title", "title",
-			"--type", "single",
-			"--user.id", "id",
-			"--user.email", "email",
-			"--user.full-name", "fullName",
-			"--user.phone-number", "phoneNumber",
-			"--user.username", "username",
-		)
-	})
-
-	t.Run("piping data", func(t *testing.T) {
-		// Test piping YAML data over stdin
-		pipeData := []byte("" +
-			"accountID: accountID\n" +
-			"allowInvite: true\n" +
-			"messageText: messageText\n" +
-			"mode: create\n" +
-			"participantIDs:\n" +
-			"  - string\n" +
-			"title: title\n" +
-			"type: single\n" +
-			"user:\n" +
-			"  id: id\n" +
-			"  email: email\n" +
-			"  fullName: fullName\n" +
-			"  phoneNumber: phoneNumber\n" +
-			"  username: username\n")
-		mocktest.TestRunMockTestWithPipeAndFlags(
-			t, pipeData,
-			"--access-token", "string",
-			"chats", "create",
-		)
-	})
-}
-
-func TestChatsRetrieve(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"chats", "retrieve",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--max-participant-count", "50",
-		)
-	})
-}
-
-func TestChatsList(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"chats", "list",
-			"--max-items", "10",
-			"--account-id", "local-whatsapp_ba_EvYDBBsZbRQAy3UOSWqG0LuTVkc",
-			"--account-id", "local-instagram_ba_eRfQMmnSNy_p7Ih7HL7RduRpKFU",
-			"--cursor", "1725489123456|c29tZUltc2dQYWdl",
-			"--direction", "before",
-		)
-	})
-}
-
-func TestChatsArchive(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"chats", "archive",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--archived=true",
-		)
-	})
-
-	t.Run("piping data", func(t *testing.T) {
-		// Test piping YAML data over stdin
-		pipeData := []byte("archived: true")
-		mocktest.TestRunMockTestWithPipeAndFlags(
-			t, pipeData,
-			"--access-token", "string",
-			"chats", "archive",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-		)
-	})
-}
-
-func TestChatsSearch(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"chats", "search",
-			"--max-items", "10",
-			"--account-id", "local-whatsapp_ba_EvYDBBsZbRQAy3UOSWqG0LuTVkc",
-			"--account-id", "local-telegram_ba_QFrb5lrLPhO3OT5MFBeTWv0x4BI",
-			"--cursor", "1725489123456|c29tZUltc2dQYWdl",
-			"--direction", "before",
-			"--inbox", "primary",
-			"--include-muted=true",
-			"--last-activity-after", "'2019-12-27T18:11:19.117Z'",
-			"--last-activity-before", "'2019-12-27T18:11:19.117Z'",
-			"--limit", "1",
-			"--query", "x",
-			"--scope", "titles",
-			"--type", "single",
-			"--unread-only=true",
-		)
-	})
-}
diff --git a/pkg/cmd/chatmessagereaction.go b/pkg/cmd/chatmessagereaction.go
deleted file mode 100644
index f72f189..0000000
--- a/pkg/cmd/chatmessagereaction.go
+++ /dev/null
@@ -1,159 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/beeper/desktop-api-cli/internal/apiquery"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-	"github.com/beeper/desktop-api-go"
-	"github.com/beeper/desktop-api-go/option"
-	"github.com/tidwall/gjson"
-	"github.com/urfave/cli/v3"
-)
-
-var chatsMessagesReactionsDelete = cli.Command{
-	Name:    "delete",
-	Usage:   "Remove the authenticated user's reaction from an existing message.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "chat-id",
-			Usage:    "Unique identifier of the chat.",
-			Required: true,
-		},
-		&requestflag.Flag[string]{
-			Name:     "message-id",
-			Required: true,
-		},
-		&requestflag.Flag[string]{
-			Name:      "reaction-key",
-			Usage:     "Reaction key to remove",
-			Required:  true,
-			QueryPath: "reactionKey",
-		},
-	},
-	Action:          handleChatsMessagesReactionsDelete,
-	HideHelpCommand: true,
-}
-
-var chatsMessagesReactionsAdd = cli.Command{
-	Name:    "add",
-	Usage:   "Add a reaction to an existing message.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "chat-id",
-			Usage:    "Unique identifier of the chat.",
-			Required: true,
-		},
-		&requestflag.Flag[string]{
-			Name:     "message-id",
-			Required: true,
-		},
-		&requestflag.Flag[string]{
-			Name:     "reaction-key",
-			Usage:    "Reaction key to add (emoji, shortcode, or custom emoji key)",
-			Required: true,
-			BodyPath: "reactionKey",
-		},
-		&requestflag.Flag[string]{
-			Name:     "transaction-id",
-			Usage:    "Optional transaction ID for deduplication and local echo tracking",
-			BodyPath: "transactionID",
-		},
-	},
-	Action:          handleChatsMessagesReactionsAdd,
-	HideHelpCommand: true,
-}
-
-func handleChatsMessagesReactionsDelete(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-	if !cmd.IsSet("message-id") && len(unusedArgs) > 0 {
-		cmd.Set("message-id", unusedArgs[0])
-		unusedArgs = unusedArgs[1:]
-	}
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.ChatMessageReactionDeleteParams{
-		ChatID: cmd.Value("chat-id").(string),
-	}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Chats.Messages.Reactions.Delete(
-		ctx,
-		cmd.Value("message-id").(string),
-		params,
-		options...,
-	)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "chats:messages:reactions delete", obj, format, transform)
-}
-
-func handleChatsMessagesReactionsAdd(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-	if !cmd.IsSet("message-id") && len(unusedArgs) > 0 {
-		cmd.Set("message-id", unusedArgs[0])
-		unusedArgs = unusedArgs[1:]
-	}
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.ChatMessageReactionAddParams{
-		ChatID: cmd.Value("chat-id").(string),
-	}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		ApplicationJSON,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Chats.Messages.Reactions.Add(
-		ctx,
-		cmd.Value("message-id").(string),
-		params,
-		options...,
-	)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "chats:messages:reactions add", obj, format, transform)
-}
diff --git a/pkg/cmd/chatmessagereaction_test.go b/pkg/cmd/chatmessagereaction_test.go
deleted file mode 100644
index 74168cd..0000000
--- a/pkg/cmd/chatmessagereaction_test.go
+++ /dev/null
@@ -1,50 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"testing"
-
-	"github.com/beeper/desktop-api-cli/internal/mocktest"
-)
-
-func TestChatsMessagesReactionsDelete(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"chats:messages:reactions", "delete",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--message-id", "messageID",
-			"--reaction-key", "x",
-		)
-	})
-}
-
-func TestChatsMessagesReactionsAdd(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"chats:messages:reactions", "add",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--message-id", "messageID",
-			"--reaction-key", "x",
-			"--transaction-id", "transactionID",
-		)
-	})
-
-	t.Run("piping data", func(t *testing.T) {
-		// Test piping YAML data over stdin
-		pipeData := []byte("" +
-			"reactionKey: x\n" +
-			"transactionID: transactionID\n")
-		mocktest.TestRunMockTestWithPipeAndFlags(
-			t, pipeData,
-			"--access-token", "string",
-			"chats:messages:reactions", "add",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--message-id", "messageID",
-		)
-	})
-}
diff --git a/pkg/cmd/chatreminder.go b/pkg/cmd/chatreminder.go
deleted file mode 100644
index 5f288e1..0000000
--- a/pkg/cmd/chatreminder.go
+++ /dev/null
@@ -1,119 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/beeper/desktop-api-cli/internal/apiquery"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-	"github.com/beeper/desktop-api-go"
-	"github.com/urfave/cli/v3"
-)
-
-var chatsRemindersCreate = requestflag.WithInnerFlags(cli.Command{
-	Name:    "create",
-	Usage:   "Set a reminder for a chat at a specific time",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "chat-id",
-			Usage:    "Unique identifier of the chat.",
-			Required: true,
-		},
-		&requestflag.Flag[map[string]any]{
-			Name:     "reminder",
-			Usage:    "Reminder configuration",
-			Required: true,
-			BodyPath: "reminder",
-		},
-	},
-	Action:          handleChatsRemindersCreate,
-	HideHelpCommand: true,
-}, map[string][]requestflag.HasOuterFlag{
-	"reminder": {
-		&requestflag.InnerFlag[float64]{
-			Name:       "reminder.remind-at-ms",
-			Usage:      "Unix timestamp in milliseconds when reminder should trigger",
-			InnerField: "remindAtMs",
-		},
-		&requestflag.InnerFlag[bool]{
-			Name:       "reminder.dismiss-on-incoming-message",
-			Usage:      "Cancel reminder if someone messages in the chat",
-			InnerField: "dismissOnIncomingMessage",
-		},
-	},
-})
-
-var chatsRemindersDelete = cli.Command{
-	Name:    "delete",
-	Usage:   "Clear an existing reminder from a chat",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "chat-id",
-			Usage:    "Unique identifier of the chat.",
-			Required: true,
-		},
-	},
-	Action:          handleChatsRemindersDelete,
-	HideHelpCommand: true,
-}
-
-func handleChatsRemindersCreate(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-	if !cmd.IsSet("chat-id") && len(unusedArgs) > 0 {
-		cmd.Set("chat-id", unusedArgs[0])
-		unusedArgs = unusedArgs[1:]
-	}
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.ChatReminderNewParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		ApplicationJSON,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	return client.Chats.Reminders.New(
-		ctx,
-		cmd.Value("chat-id").(string),
-		params,
-		options...,
-	)
-}
-
-func handleChatsRemindersDelete(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-	if !cmd.IsSet("chat-id") && len(unusedArgs) > 0 {
-		cmd.Set("chat-id", unusedArgs[0])
-		unusedArgs = unusedArgs[1:]
-	}
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	return client.Chats.Reminders.Delete(ctx, cmd.Value("chat-id").(string), options...)
-}
diff --git a/pkg/cmd/chatreminder_test.go b/pkg/cmd/chatreminder_test.go
deleted file mode 100644
index 84f08fb..0000000
--- a/pkg/cmd/chatreminder_test.go
+++ /dev/null
@@ -1,62 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"testing"
-
-	"github.com/beeper/desktop-api-cli/internal/mocktest"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-)
-
-func TestChatsRemindersCreate(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"chats:reminders", "create",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--reminder", "{remindAtMs: 0, dismissOnIncomingMessage: true}",
-		)
-	})
-
-	t.Run("inner flags", func(t *testing.T) {
-		// Check that inner flags have been set up correctly
-		requestflag.CheckInnerFlags(chatsRemindersCreate)
-
-		// Alternative argument passing style using inner flags
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"chats:reminders", "create",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--reminder.remind-at-ms", "0",
-			"--reminder.dismiss-on-incoming-message=true",
-		)
-	})
-
-	t.Run("piping data", func(t *testing.T) {
-		// Test piping YAML data over stdin
-		pipeData := []byte("" +
-			"reminder:\n" +
-			"  remindAtMs: 0\n" +
-			"  dismissOnIncomingMessage: true\n")
-		mocktest.TestRunMockTestWithPipeAndFlags(
-			t, pipeData,
-			"--access-token", "string",
-			"chats:reminders", "create",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-		)
-	})
-}
-
-func TestChatsRemindersDelete(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"chats:reminders", "delete",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-		)
-	})
-}
diff --git a/pkg/cmd/cmd.go b/pkg/cmd/cmd.go
deleted file mode 100644
index 3351e7f..0000000
--- a/pkg/cmd/cmd.go
+++ /dev/null
@@ -1,239 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"bytes"
-	"compress/gzip"
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
-
-	"github.com/beeper/desktop-api-cli/internal/autocomplete"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-	docs "github.com/urfave/cli-docs/v3"
-	"github.com/urfave/cli/v3"
-)
-
-var (
-	Command            *cli.Command
-	CommandErrorBuffer bytes.Buffer
-)
-
-func init() {
-	Command = &cli.Command{
-		Name:      "beeper-desktop-cli",
-		Usage:     "CLI for the beeperdesktop API",
-		Suggest:   true,
-		Version:   Version,
-		ErrWriter: &CommandErrorBuffer,
-		Flags: []cli.Flag{
-			&cli.BoolFlag{
-				Name:  "debug",
-				Usage: "Enable debug logging",
-			},
-			&cli.StringFlag{
-				Name:        "base-url",
-				DefaultText: "url",
-				Usage:       "Override the base URL for API requests",
-			},
-			&cli.StringFlag{
-				Name:  "format",
-				Usage: "The format for displaying response data (one of: " + strings.Join(OutputFormats, ", ") + ")",
-				Value: "pretty",
-				Validator: func(format string) error {
-					if !slices.Contains(OutputFormats, strings.ToLower(format)) {
-						return fmt.Errorf("format must be one of: %s", strings.Join(OutputFormats, ", "))
-					}
-					return nil
-				},
-			},
-			&cli.StringFlag{
-				Name:  "format-error",
-				Usage: "The format for displaying error data (one of: " + strings.Join(OutputFormats, ", ") + ")",
-				Value: "pretty",
-				Validator: func(format string) error {
-					if !slices.Contains(OutputFormats, strings.ToLower(format)) {
-						return fmt.Errorf("format must be one of: %s", strings.Join(OutputFormats, ", "))
-					}
-					return nil
-				},
-			},
-			&cli.StringFlag{
-				Name:  "transform",
-				Usage: "The GJSON transformation for data output.",
-			},
-			&cli.StringFlag{
-				Name:  "transform-error",
-				Usage: "The GJSON transformation for errors.",
-			},
-			&requestflag.Flag[string]{
-				Name:    "access-token",
-				Usage:   "Bearer access token obtained via OAuth2 PKCE flow or created in-app. Required for all API operations.",
-				Sources: cli.EnvVars("BEEPER_ACCESS_TOKEN"),
-			},
-		},
-		Commands: []*cli.Command{
-			&focus,
-			&search,
-			{
-				Name:     "accounts",
-				Category: "API RESOURCE",
-				Suggest:  true,
-				Commands: []*cli.Command{
-					&accountsList,
-				},
-			},
-			{
-				Name:     "accounts:contacts",
-				Category: "API RESOURCE",
-				Suggest:  true,
-				Commands: []*cli.Command{
-					&accountsContactsList,
-					&accountsContactsSearch,
-				},
-			},
-			{
-				Name:     "chats",
-				Category: "API RESOURCE",
-				Suggest:  true,
-				Commands: []*cli.Command{
-					&chatsCreate,
-					&chatsRetrieve,
-					&chatsList,
-					&chatsArchive,
-					&chatsSearch,
-				},
-			},
-			{
-				Name:     "chats:reminders",
-				Category: "API RESOURCE",
-				Suggest:  true,
-				Commands: []*cli.Command{
-					&chatsRemindersCreate,
-					&chatsRemindersDelete,
-				},
-			},
-			{
-				Name:     "chats:messages:reactions",
-				Category: "API RESOURCE",
-				Suggest:  true,
-				Commands: []*cli.Command{
-					&chatsMessagesReactionsDelete,
-					&chatsMessagesReactionsAdd,
-				},
-			},
-			{
-				Name:     "messages",
-				Category: "API RESOURCE",
-				Suggest:  true,
-				Commands: []*cli.Command{
-					&messagesUpdate,
-					&messagesList,
-					&messagesSearch,
-					&messagesSend,
-				},
-			},
-			{
-				Name:     "assets",
-				Category: "API RESOURCE",
-				Suggest:  true,
-				Commands: []*cli.Command{
-					&assetsDownload,
-					&assetsServe,
-					&assetsUpload,
-					&assetsUploadBase64,
-				},
-			},
-			{
-				Name:     "info",
-				Category: "API RESOURCE",
-				Suggest:  true,
-				Commands: []*cli.Command{
-					&infoRetrieve,
-				},
-			},
-			{
-				Name:            "@manpages",
-				Usage:           "Generate documentation for 'man'",
-				UsageText:       "beeper-desktop-cli @manpages [-o beeper-desktop-cli.1] [--gzip]",
-				Hidden:          true,
-				Action:          generateManpages,
-				HideHelpCommand: true,
-				Flags: []cli.Flag{
-					&cli.StringFlag{
-						Name:    "output",
-						Aliases: []string{"o"},
-						Usage:   "write manpages to the given folder",
-						Value:   "man",
-					},
-					&cli.BoolFlag{
-						Name:    "gzip",
-						Aliases: []string{"z"},
-						Usage:   "output gzipped manpage files to .gz",
-						Value:   true,
-					},
-					&cli.BoolFlag{
-						Name:    "text",
-						Aliases: []string{"z"},
-						Usage:   "output uncompressed text files",
-						Value:   false,
-					},
-				},
-			},
-			{
-				Name:            "__complete",
-				Hidden:          true,
-				HideHelpCommand: true,
-				Action:          autocomplete.ExecuteShellCompletion,
-			},
-			{
-				Name:            "@completion",
-				Hidden:          true,
-				HideHelpCommand: true,
-				Action:          autocomplete.OutputCompletionScript,
-			},
-		},
-		HideHelpCommand: true,
-	}
-}
-
-func generateManpages(ctx context.Context, c *cli.Command) error {
-	manpage, err := docs.ToManWithSection(Command, 1)
-	if err != nil {
-		return err
-	}
-	dir := c.String("output")
-	err = os.MkdirAll(filepath.Join(dir, "man1"), 0755)
-	if err != nil {
-		// handle error
-	}
-	if c.Bool("text") {
-		file, err := os.Create(filepath.Join(dir, "man1", "beeper-desktop-cli.1"))
-		if err != nil {
-			return err
-		}
-		defer file.Close()
-		if _, err := file.WriteString(manpage); err != nil {
-			return err
-		}
-	}
-	if c.Bool("gzip") {
-		file, err := os.Create(filepath.Join(dir, "man1", "beeper-desktop-cli.1.gz"))
-		if err != nil {
-			return err
-		}
-		defer file.Close()
-		gzWriter := gzip.NewWriter(file)
-		defer gzWriter.Close()
-		_, err = gzWriter.Write([]byte(manpage))
-		if err != nil {
-			return err
-		}
-	}
-	fmt.Printf("Wrote manpages to %s\n", dir)
-	return nil
-}
diff --git a/pkg/cmd/cmdutil.go b/pkg/cmd/cmdutil.go
deleted file mode 100644
index 9b24177..0000000
--- a/pkg/cmd/cmdutil.go
+++ /dev/null
@@ -1,465 +0,0 @@
-package cmd
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"mime"
-	"net/http"
-	"net/http/httputil"
-	"os"
-	"os/exec"
-	"os/signal"
-	"path/filepath"
-	"strings"
-	"syscall"
-
-	"github.com/beeper/desktop-api-cli/internal/jsonview"
-	"github.com/beeper/desktop-api-go/option"
-
-	"github.com/charmbracelet/x/term"
-	"github.com/itchyny/json2yaml"
-	"github.com/muesli/reflow/wrap"
-	"github.com/tidwall/gjson"
-	"github.com/tidwall/pretty"
-	"github.com/urfave/cli/v3"
-)
-
-var OutputFormats = []string{"auto", "explore", "json", "jsonl", "pretty", "raw", "yaml"}
-
-func getDefaultRequestOptions(cmd *cli.Command) []option.RequestOption {
-	opts := []option.RequestOption{
-		option.WithHeader("User-Agent", fmt.Sprintf("BeeperDesktop/CLI %s", Version)),
-		option.WithHeader("X-Stainless-Lang", "cli"),
-		option.WithHeader("X-Stainless-Package-Version", Version),
-		option.WithHeader("X-Stainless-Runtime", "cli"),
-		option.WithHeader("X-Stainless-CLI-Command", cmd.FullName()),
-	}
-	if cmd.IsSet("access-token") {
-		opts = append(opts, option.WithAccessToken(cmd.String("access-token")))
-	}
-
-	// Override base URL if the --base-url flag is provided
-	if baseURL := cmd.String("base-url"); baseURL != "" {
-		opts = append(opts, option.WithBaseURL(baseURL))
-	}
-
-	return opts
-}
-
-var debugMiddlewareOption = option.WithMiddleware(
-	func(r *http.Request, mn option.MiddlewareNext) (*http.Response, error) {
-		logger := log.Default()
-
-		if reqBytes, err := httputil.DumpRequest(r, true); err == nil {
-			logger.Printf("Request Content:\n%s\n", reqBytes)
-		}
-
-		resp, err := mn(r)
-		if err != nil {
-			return resp, err
-		}
-
-		if respBytes, err := httputil.DumpResponse(resp, true); err == nil {
-			logger.Printf("Response Content:\n%s\n", respBytes)
-		}
-
-		return resp, err
-	},
-)
-
-// isInputPiped tries to check for input being piped into the CLI which tells us that we should try to read
-// from stdin. This can be a bit tricky in some cases like when an stdin is connected to a pipe but nothing is
-// being piped in (this may happen in some environments like Cursor's integration terminal or CI), which is
-// why this function is a little more elaborate than it'd be otherwise.
-func isInputPiped() bool {
-	stat, err := os.Stdin.Stat()
-	if err != nil {
-		return false
-	}
-
-	mode := stat.Mode()
-
-	// Regular file (redirect like < file.txt) — only if non-empty.
-	//
-	// Notably, on Unix the case like `< /dev/null` is handled below because `/dev/null` is not a regular
-	// file. On Windows, NUL appears as a regular file with size 0, so it's also handled correctly.
-	if mode.IsRegular() && stat.Size() > 0 {
-		return true
-	}
-
-	// For pipes/sockets (e.g. `echo foo | stainlesscli`), use an OS-specific check to determine whether
-	// data is actually available. Some environments like Cursor's integrated terminal connect stdin as a
-	// pipe even when nothing is being piped.
-	if mode&(os.ModeNamedPipe|os.ModeSocket) != 0 {
-		// Defined in either cmdutil_unix.go or cmdutil_windows.go.
-		return isPipedDataAvailableOSSpecific()
-	}
-
-	return false
-}
-
-func isTerminal(w io.Writer) bool {
-	switch v := w.(type) {
-	case *os.File:
-		return term.IsTerminal(v.Fd())
-	default:
-		return false
-	}
-}
-
-func streamOutput(label string, generateOutput func(w *os.File) error) error {
-	// For non-tty output (probably a pipe), write directly to stdout
-	if !isTerminal(os.Stdout) {
-		return streamToStdout(generateOutput)
-	}
-
-	// When streaming output on Unix-like systems, there's a special trick involving creating two socket pairs
-	// that we prefer because it supports small buffer sizes which results in less pagination per buffer. The
-	// constructs needed to run it don't exist on Windows builds, so we have this function broken up into
-	// OS-specific files with conditional build comments. Under Windows (and in case our fancy constructs fail
-	// on Unix), we fall back to using pipes (`streamToPagerWithPipe`), which are OS agnostic.
-	//
-	// Defined in either cmdutil_unix.go or cmdutil_windows.go.
-	return streamOutputOSSpecific(label, generateOutput)
-}
-
-func streamToPagerWithPipe(label string, generateOutput func(w *os.File) error) error {
-	r, w, err := os.Pipe()
-	if err != nil {
-		return err
-	}
-	defer r.Close()
-	defer w.Close()
-
-	pagerProgram := os.Getenv("PAGER")
-	if pagerProgram == "" {
-		pagerProgram = "less"
-	}
-
-	if _, err := exec.LookPath(pagerProgram); err != nil {
-		return err
-	}
-
-	cmd := exec.Command(pagerProgram)
-	cmd.Stdin = r
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	cmd.Env = append(os.Environ(),
-		"LESS=-X -r -P "+label,
-		"MORE=-r -P "+label,
-	)
-
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	if err := r.Close(); err != nil {
-		return err
-	}
-
-	// If we would be streaming to a terminal and aren't forcing color one way
-	// or the other, we should configure things to use color so the pager gets
-	// colorized input.
-	if isTerminal(os.Stdout) && os.Getenv("FORCE_COLOR") == "" {
-		os.Setenv("FORCE_COLOR", "1")
-	}
-
-	if err := generateOutput(w); err != nil && !strings.Contains(err.Error(), "broken pipe") {
-		return err
-	}
-
-	w.Close()
-	return cmd.Wait()
-}
-
-func streamToStdout(generateOutput func(w *os.File) error) error {
-	signal.Ignore(syscall.SIGPIPE)
-	err := generateOutput(os.Stdout)
-	if err != nil && strings.Contains(err.Error(), "broken pipe") {
-		return nil
-	}
-	return err
-}
-
-func writeBinaryResponse(response *http.Response, outfile string) (string, error) {
-	defer response.Body.Close()
-	body, err := io.ReadAll(response.Body)
-	if err != nil {
-		return "", err
-	}
-	switch outfile {
-	case "-", "/dev/stdout":
-		_, err := os.Stdout.Write(body)
-		return "", err
-	case "":
-		// If output file is unspecified, then print to stdout for plain text or
-		// if stdout is not a terminal:
-		if !isTerminal(os.Stdout) || isUTF8TextFile(body) {
-			_, err := os.Stdout.Write(body)
-			return "", err
-		}
-
-		// If response has a suggested filename in the content-disposition
-		// header, then use that (with an optional suffix to ensure uniqueness):
-		file, err := createDownloadFile(response, body)
-		if err != nil {
-			return "", err
-		}
-		defer file.Close()
-		if _, err := file.Write(body); err != nil {
-			return "", err
-		}
-		return fmt.Sprintf("Wrote output to: %s", file.Name()), nil
-	default:
-		if err := os.WriteFile(outfile, body, 0644); err != nil {
-			return "", err
-		}
-		return fmt.Sprintf("Wrote output to: %s", outfile), nil
-	}
-}
-
-// Return a writable file handle to a new file, which attempts to choose a good filename
-// based on the Content-Disposition header or sniffing the MIME filetype of the response.
-func createDownloadFile(response *http.Response, data []byte) (*os.File, error) {
-	filename := "file"
-	// If the header provided an output filename, use that
-	disp := response.Header.Get("Content-Disposition")
-	_, params, err := mime.ParseMediaType(disp)
-	if err == nil {
-		if dispFilename, ok := params["filename"]; ok {
-			// Only use the last path component to prevent directory traversal
-			filename = filepath.Base(dispFilename)
-			// Try to create the file with exclusive flag to avoid race conditions
-			file, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644)
-			if err == nil {
-				return file, nil
-			}
-		}
-	}
-
-	// If file already exists, create a unique filename using CreateTemp
-	ext := filepath.Ext(filename)
-	if ext == "" {
-		ext = guessExtension(data)
-	}
-	base := strings.TrimSuffix(filename, ext)
-	return os.CreateTemp(".", base+"-*"+ext)
-}
-
-func guessExtension(data []byte) string {
-	ct := http.DetectContentType(data)
-
-	// Prefer common extensions over obscure ones
-	switch ct {
-	case "application/gzip":
-		return ".gz"
-	case "application/pdf":
-		return ".pdf"
-	case "application/zip":
-		return ".zip"
-	case "audio/mpeg":
-		return ".mp3"
-	case "image/bmp":
-		return ".bmp"
-	case "image/gif":
-		return ".gif"
-	case "image/jpeg":
-		return ".jpg"
-	case "image/png":
-		return ".png"
-	case "image/webp":
-		return ".webp"
-	case "video/mp4":
-		return ".mp4"
-	}
-
-	exts, err := mime.ExtensionsByType(ct)
-	if err == nil && len(exts) > 0 {
-		return exts[0]
-	} else if isUTF8TextFile(data) {
-		return ".txt"
-	} else {
-		return ".bin"
-	}
-}
-
-func shouldUseColors(w io.Writer) bool {
-	force, ok := os.LookupEnv("FORCE_COLOR")
-	if ok {
-		if force == "1" {
-			return true
-		}
-		if force == "0" {
-			return false
-		}
-	}
-	return isTerminal(w)
-}
-
-func formatJSON(expectedOutput *os.File, title string, res gjson.Result, format string, transform string) ([]byte, error) {
-	if format != "raw" && transform != "" {
-		transformed := res.Get(transform)
-		if transformed.Exists() {
-			res = transformed
-		}
-	}
-	switch strings.ToLower(format) {
-	case "auto":
-		return formatJSON(expectedOutput, title, res, "json", "")
-	case "pretty":
-		return []byte(jsonview.RenderJSON(title, res) + "\n"), nil
-	case "json":
-		prettyJSON := pretty.Pretty([]byte(res.Raw))
-		if shouldUseColors(expectedOutput) {
-			return pretty.Color(prettyJSON, pretty.TerminalStyle), nil
-		} else {
-			return prettyJSON, nil
-		}
-	case "jsonl":
-		// @ugly is gjson syntax for "no whitespace", so it fits on one line
-		oneLineJSON := res.Get("@ugly").Raw
-		if shouldUseColors(expectedOutput) {
-			bytes := append(pretty.Color([]byte(oneLineJSON), pretty.TerminalStyle), '\n')
-			return bytes, nil
-		} else {
-			return []byte(oneLineJSON + "\n"), nil
-		}
-	case "raw":
-		return []byte(res.Raw + "\n"), nil
-	case "yaml":
-		input := strings.NewReader(res.Raw)
-		var yaml strings.Builder
-		if err := json2yaml.Convert(&yaml, input); err != nil {
-			return nil, err
-		}
-		_, err := expectedOutput.Write([]byte(yaml.String()))
-		return nil, err
-	default:
-		return nil, fmt.Errorf("Invalid format: %s, valid formats are: %s", format, strings.Join(OutputFormats, ", "))
-	}
-}
-
-// Display JSON to the user in various different formats
-func ShowJSON(out *os.File, title string, res gjson.Result, format string, transform string) error {
-	if format != "raw" && transform != "" {
-		transformed := res.Get(transform)
-		if transformed.Exists() {
-			res = transformed
-		}
-	}
-
-	switch strings.ToLower(format) {
-	case "auto":
-		return ShowJSON(out, title, res, "json", "")
-	case "explore":
-		return jsonview.ExploreJSON(title, res)
-	default:
-		bytes, err := formatJSON(out, title, res, format, transform)
-		if err != nil {
-			return err
-		}
-
-		_, err = out.Write(bytes)
-		return err
-	}
-}
-
-// Get the number of lines that would be output by writing the data to the terminal
-func countTerminalLines(data []byte, terminalWidth int) int {
-	return bytes.Count([]byte(wrap.String(string(data), terminalWidth)), []byte("\n"))
-}
-
-type HasRawJSON interface {
-	RawJSON() string
-}
-
-// For an iterator over different value types, display its values to the user in
-// different formats.
-func ShowJSONIterator[T any](stdout *os.File, title string, iter jsonview.Iterator[T], format string, transform string, itemsToDisplay int64) error {
-	if format == "explore" {
-		return jsonview.ExploreJSONStream(title, iter)
-	}
-
-	terminalWidth, terminalHeight, err := term.GetSize(os.Stdout.Fd())
-	if err != nil {
-		terminalWidth = 100
-		terminalHeight = 40
-	}
-
-	// Decide whether or not to use a pager based on whether it's a short output or a long output
-	usePager := false
-	output := []byte{}
-	numberOfNewlines := 0
-	for iter.Next() {
-		if itemsToDisplay == 0 {
-			break
-		}
-		item := iter.Current()
-		var obj gjson.Result
-		if hasRaw, ok := any(item).(HasRawJSON); ok {
-			obj = gjson.Parse(hasRaw.RawJSON())
-		} else {
-			jsonData, err := json.Marshal(item)
-			if err != nil {
-				return err
-			}
-			obj = gjson.ParseBytes(jsonData)
-		}
-		json, err := formatJSON(stdout, title, obj, format, transform)
-		if err != nil {
-			return err
-		}
-
-		output = append(output, json...)
-		itemsToDisplay -= 1
-		numberOfNewlines += countTerminalLines(json, terminalWidth)
-
-		// If the output won't fit in the terminal window, stream it to a pager
-		if numberOfNewlines >= terminalHeight-3 {
-			usePager = true
-			break
-		}
-	}
-
-	if !usePager {
-		_, err := stdout.Write(output)
-		if err != nil {
-			return err
-		}
-
-		return iter.Err()
-	}
-
-	return streamOutput(title, func(pager *os.File) error {
-		// Write the output we used during the initial terminal size computation
-		_, err := pager.Write(output)
-		if err != nil {
-			return err
-		}
-
-		for iter.Next() {
-			if itemsToDisplay == 0 {
-				break
-			}
-			item := iter.Current()
-			var obj gjson.Result
-			if hasRaw, ok := any(item).(HasRawJSON); ok {
-				obj = gjson.Parse(hasRaw.RawJSON())
-			} else {
-				jsonData, err := json.Marshal(item)
-				if err != nil {
-					return err
-				}
-				obj = gjson.ParseBytes(jsonData)
-			}
-			if err := ShowJSON(pager, title, obj, format, transform); err != nil {
-				return err
-			}
-			itemsToDisplay -= 1
-		}
-		return iter.Err()
-	})
-}
diff --git a/pkg/cmd/cmdutil_test.go b/pkg/cmd/cmdutil_test.go
deleted file mode 100644
index 0a46fd1..0000000
--- a/pkg/cmd/cmdutil_test.go
+++ /dev/null
@@ -1,127 +0,0 @@
-package cmd
-
-import (
-	"bytes"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestStreamOutput(t *testing.T) {
-	t.Setenv("PAGER", "cat")
-	err := streamOutput("stream test", func(w *os.File) error {
-		_, writeErr := w.WriteString("Hello world\n")
-		return writeErr
-	})
-	if err != nil {
-		t.Errorf("streamOutput failed: %v", err)
-	}
-}
-
-func TestWriteBinaryResponse(t *testing.T) {
-	t.Run("write to explicit file", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		outfile := tmpDir + "/output.txt"
-		body := []byte("test content")
-		resp := &http.Response{
-			Body: io.NopCloser(bytes.NewReader(body)),
-		}
-
-		msg, err := writeBinaryResponse(resp, outfile)
-
-		require.NoError(t, err)
-		assert.Contains(t, msg, outfile)
-
-		content, err := os.ReadFile(outfile)
-		require.NoError(t, err)
-		assert.Equal(t, body, content)
-	})
-
-	t.Run("write to stdout", func(t *testing.T) {
-		oldStdout := os.Stdout
-		r, w, _ := os.Pipe()
-		os.Stdout = w
-
-		body := []byte("stdout content")
-		resp := &http.Response{
-			Body: io.NopCloser(bytes.NewReader(body)),
-		}
-		msg, err := writeBinaryResponse(resp, "-")
-
-		w.Close()
-		os.Stdout = oldStdout
-
-		require.NoError(t, err)
-		assert.Empty(t, msg)
-
-		var buf bytes.Buffer
-		_, _ = buf.ReadFrom(r)
-		assert.Equal(t, body, buf.Bytes())
-	})
-}
-
-func TestCreateDownloadFile(t *testing.T) {
-	t.Run("creates file with filename from header", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		oldWd, _ := os.Getwd()
-		os.Chdir(tmpDir)
-		defer os.Chdir(oldWd)
-
-		resp := &http.Response{
-			Header: http.Header{
-				"Content-Disposition": []string{`attachment; filename="test.txt"`},
-			},
-		}
-		file, err := createDownloadFile(resp, []byte("test content"))
-		require.NoError(t, err)
-		defer file.Close()
-		assert.Equal(t, "test.txt", filepath.Base(file.Name()))
-
-		// Create a second file with the same name to ensure it doesn't clobber the first
-		resp2 := &http.Response{
-			Header: http.Header{
-				"Content-Disposition": []string{`attachment; filename="test.txt"`},
-			},
-		}
-		file2, err := createDownloadFile(resp2, []byte("second content"))
-		require.NoError(t, err)
-		defer file2.Close()
-		assert.NotEqual(t, file.Name(), file2.Name(), "second file should have a different name")
-		assert.Contains(t, filepath.Base(file2.Name()), "test")
-	})
-
-	t.Run("creates temp file when no header", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		oldWd, _ := os.Getwd()
-		os.Chdir(tmpDir)
-		defer os.Chdir(oldWd)
-
-		resp := &http.Response{Header: http.Header{}}
-		file, err := createDownloadFile(resp, []byte("test content"))
-		require.NoError(t, err)
-		defer file.Close()
-		assert.Contains(t, filepath.Base(file.Name()), "file-")
-	})
-
-	t.Run("prevents directory traversal", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		oldWd, _ := os.Getwd()
-		os.Chdir(tmpDir)
-		defer os.Chdir(oldWd)
-
-		resp := &http.Response{
-			Header: http.Header{
-				"Content-Disposition": []string{`attachment; filename="../../../etc/passwd"`},
-			},
-		}
-		file, err := createDownloadFile(resp, []byte("test content"))
-		require.NoError(t, err)
-		defer file.Close()
-		assert.Equal(t, "passwd", filepath.Base(file.Name()))
-	})
-}
diff --git a/pkg/cmd/cmdutil_unix.go b/pkg/cmd/cmdutil_unix.go
deleted file mode 100644
index edefcd7..0000000
--- a/pkg/cmd/cmdutil_unix.go
+++ /dev/null
@@ -1,127 +0,0 @@
-//go:build !windows
-
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-	"syscall"
-
-	"golang.org/x/sys/unix"
-)
-
-func isPipedDataAvailableOSSpecific() bool {
-	// Try to determine if there's non-empty data being piped into the command by polling for data for a short
-	// amount of time. This is necessary because some environments (e.g. Cursor's integrated terminal) connect
-	// stdin as a pipe even when nothing is being piped, which would cause the command to block indefinitely
-	// waiting for input that will never come. The 10 ms timeout is arbitrary -- designed to be long enough to
-	// allow data to be detected, but short enough that it shouldn't cause a noticeable delay in command runs.
-	fds := []unix.PollFd{{Fd: int32(os.Stdin.Fd()), Events: unix.POLLIN}}
-	n, _ := unix.Poll(fds, 10 /* ms */)
-	return n > 0
-}
-
-func streamOutputOSSpecific(label string, generateOutput func(w *os.File) error) error {
-	// Try to use socket pair for better buffer control
-	pagerInput, pid, err := openSocketPairPager(label)
-	if err != nil || pagerInput == nil {
-		// Fall back to pipe if socket setup fails
-		return streamToPagerWithPipe(label, generateOutput)
-	}
-	defer pagerInput.Close()
-
-	// If we would be streaming to a terminal and aren't forcing color one way
-	// or the other, we should configure things to use color so the pager gets
-	// colorized input.
-	if isTerminal(os.Stdout) && os.Getenv("FORCE_COLOR") == "" {
-		os.Setenv("FORCE_COLOR", "1")
-	}
-
-	// If the pager exits before reading all input, then generateOutput() will
-	// produce a broken pipe error, which is fine and we don't want to propagate it.
-	if err := generateOutput(pagerInput); err != nil &&
-		!strings.Contains(err.Error(), "broken pipe") {
-		return err
-	}
-
-	// Close the file NOW before we wait for the child process to terminate.
-	// This way, the child will receive the end-of-file signal and know that
-	// there is no more input. Otherwise the child process may block
-	// indefinitely waiting for another line (this can happen when streaming
-	// less than a screenful of data to a pager).
-	pagerInput.Close()
-
-	// Wait for child process to exit
-	var wstatus syscall.WaitStatus
-	_, err = syscall.Wait4(pid, &wstatus, 0, nil)
-	if wstatus.ExitStatus() != 0 {
-		return fmt.Errorf("Pager exited with non-zero exit status: %d", wstatus.ExitStatus())
-	}
-	return err
-}
-
-func openSocketPairPager(label string) (*os.File, int, error) {
-	fds, err := unix.Socketpair(unix.AF_UNIX, unix.SOCK_STREAM, 0)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	// The child file descriptor will be sent to the child process through
-	// ProcAttr and ForkExec(), while the parent process will always close the
-	// child file descriptor.
-	// The parent file descriptor will be wrapped in an os.File wrapper and
-	// returned from this function, or closed if something goes wrong.
-	parentFd, childFd := fds[0], fds[1]
-	defer unix.Close(childFd)
-
-	// Use small buffer sizes so we don't ask the server for more paginated
-	// values than we actually need.
-	if err := unix.SetsockoptInt(parentFd, unix.SOL_SOCKET, unix.SO_SNDBUF, 128); err != nil {
-		unix.Close(parentFd)
-		return nil, 0, err
-	}
-	if err := unix.SetsockoptInt(childFd, unix.SOL_SOCKET, unix.SO_RCVBUF, 128); err != nil {
-		unix.Close(parentFd)
-		return nil, 0, err
-	}
-
-	// Set CLOEXEC on the parent file descriptor so it doesn't leak to child
-	syscall.CloseOnExec(parentFd)
-
-	parentConn := os.NewFile(uintptr(parentFd), "parent-socket")
-
-	pagerProgram := os.Getenv("PAGER")
-	if pagerProgram == "" {
-		pagerProgram = "less"
-	}
-
-	pagerPath, err := exec.LookPath(pagerProgram)
-	if err != nil {
-		unix.Close(parentFd)
-		return nil, 0, err
-	}
-
-	env := os.Environ()
-	env = append(env, "LESS=-r -P "+label)
-	env = append(env, "MORE=-r -P "+label)
-
-	procAttr := &syscall.ProcAttr{
-		Dir: "",
-		Env: env,
-		Files: []uintptr{
-			uintptr(childFd),        // stdin (fd 0)
-			uintptr(syscall.Stdout), // stdout (fd 1)
-			uintptr(syscall.Stderr), // stderr (fd 2)
-		},
-	}
-
-	pid, err := syscall.ForkExec(pagerPath, []string{pagerProgram}, procAttr)
-	if err != nil {
-		unix.Close(parentFd)
-		return nil, 0, err
-	}
-
-	return parentConn, pid, nil
-}
diff --git a/pkg/cmd/cmdutil_windows.go b/pkg/cmd/cmdutil_windows.go
deleted file mode 100644
index 49b025e..0000000
--- a/pkg/cmd/cmdutil_windows.go
+++ /dev/null
@@ -1,35 +0,0 @@
-//go:build windows
-
-package cmd
-
-import (
-	"os"
-	"syscall"
-	"unsafe"
-)
-
-var (
-	kernel32          = syscall.NewLazyDLL("kernel32.dll")
-	procPeekNamedPipe = kernel32.NewProc("PeekNamedPipe")
-)
-
-func isPipedDataAvailableOSSpecific() bool {
-	// On Windows, unix.Poll is not available. Use PeekNamedPipe to check if data is available
-	// on the pipe without consuming it.
-	var available uint32
-	r, _, _ := procPeekNamedPipe.Call(
-		os.Stdin.Fd(),
-		0,
-		0,
-		0,
-		uintptr(unsafe.Pointer(&available)),
-		0,
-	)
-	return r != 0 && available > 0
-}
-
-func streamOutputOSSpecific(label string, generateOutput func(w *os.File) error) error {
-	// We have a trick with sockets that we use when possible on Unix-like systems. Those APIs aren't
-	// available on Windows, so we fall back to using pipes.
-	return streamToPagerWithPipe(label, generateOutput)
-}
diff --git a/pkg/cmd/flagoptions.go b/pkg/cmd/flagoptions.go
deleted file mode 100644
index 4a39cd0..0000000
--- a/pkg/cmd/flagoptions.go
+++ /dev/null
@@ -1,375 +0,0 @@
-package cmd
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io"
-	"maps"
-	"mime/multipart"
-	"net/http"
-	"os"
-	"reflect"
-	"strings"
-	"unicode/utf8"
-
-	"github.com/beeper/desktop-api-cli/internal/apiform"
-	"github.com/beeper/desktop-api-cli/internal/apiquery"
-	"github.com/beeper/desktop-api-cli/internal/debugmiddleware"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-	"github.com/beeper/desktop-api-go/option"
-
-	"github.com/goccy/go-yaml"
-	"github.com/urfave/cli/v3"
-)
-
-type BodyContentType int
-
-const (
-	EmptyBody BodyContentType = iota
-	MultipartFormEncoded
-	ApplicationJSON
-	ApplicationOctetStream
-)
-
-type FileEmbedStyle int
-
-const (
-	EmbedText FileEmbedStyle = iota
-	EmbedIOReader
-)
-
-func embedFiles(obj any, embedStyle FileEmbedStyle) (any, error) {
-	if obj == nil {
-		return obj, nil
-	}
-	v := reflect.ValueOf(obj)
-	result, err := embedFilesValue(v, embedStyle)
-	if err != nil {
-		return nil, err
-	}
-	return result.Interface(), nil
-}
-
-// Replace "@file.txt" with the file's contents inside a value
-func embedFilesValue(v reflect.Value, embedStyle FileEmbedStyle) (reflect.Value, error) {
-	// Unwrap interface values to get the concrete type
-	if v.Kind() == reflect.Interface {
-		if v.IsNil() {
-			return v, nil
-		}
-		v = v.Elem()
-	}
-
-	switch v.Kind() {
-	case reflect.Map:
-		if v.Len() == 0 {
-			return v, nil
-		}
-		// Always create map[string]any to handle potential type changes when embedding files
-		result := reflect.MakeMap(reflect.TypeOf(map[string]any{}))
-
-		iter := v.MapRange()
-		for iter.Next() {
-			key := iter.Key()
-			val := iter.Value()
-			newVal, err := embedFilesValue(val, embedStyle)
-			if err != nil {
-				return reflect.Value{}, err
-			}
-			result.SetMapIndex(key, newVal)
-		}
-		return result, nil
-
-	case reflect.Slice, reflect.Array:
-		if v.Len() == 0 {
-			return v, nil
-		}
-		// Use `[]any` to allow for types to change when embedding files
-		result := reflect.MakeSlice(reflect.TypeOf([]any{}), v.Len(), v.Len())
-		for i := 0; i < v.Len(); i++ {
-			newVal, err := embedFilesValue(v.Index(i), embedStyle)
-			if err != nil {
-				return reflect.Value{}, err
-			}
-			result.Index(i).Set(newVal)
-		}
-		return result, nil
-
-	case reflect.String:
-		s := v.String()
-		if literal, ok := strings.CutPrefix(s, "\\@"); ok {
-			// Allow for escaped @ signs if you don't want them to be treated as files
-			return reflect.ValueOf("@" + literal), nil
-		}
-
-		if embedStyle == EmbedText {
-			if filename, ok := strings.CutPrefix(s, "@data://"); ok {
-				// The "@data://" prefix is for files you explicitly want to upload
-				// as base64-encoded (even if the file itself is plain text)
-				content, err := os.ReadFile(filename)
-				if err != nil {
-					return v, err
-				}
-				return reflect.ValueOf(base64.StdEncoding.EncodeToString(content)), nil
-			} else if filename, ok := strings.CutPrefix(s, "@file://"); ok {
-				// The "@file://" prefix is for files that you explicitly want to
-				// upload as a string literal with backslash escapes (not base64
-				// encoded)
-				content, err := os.ReadFile(filename)
-				if err != nil {
-					return v, err
-				}
-				return reflect.ValueOf(string(content)), nil
-			} else if filename, ok := strings.CutPrefix(s, "@"); ok {
-				content, err := os.ReadFile(filename)
-				if err != nil {
-					// If the string is "@username", it's probably supposed to be a
-					// string literal and not a file reference. However, if the
-					// string looks like "@file.txt" or "@/tmp/file", then it's
-					// probably supposed to be a file.
-					probablyFile := strings.Contains(filename, ".") || strings.Contains(filename, "/")
-					if probablyFile {
-						// Give a useful error message if the user tried to upload a
-						// file, but the file couldn't be read (e.g. mistyped
-						// filename or permission error)
-						return v, err
-					}
-					// Fall back to the raw value if the user provided something
-					// like "@username" that's not intended to be a file.
-					return v, nil
-				}
-				// If the file looks like a plain text UTF8 file format, then use the contents directly.
-				if isUTF8TextFile(content) {
-					return reflect.ValueOf(string(content)), nil
-				}
-				// Otherwise it's a binary file, so encode it with base64
-				return reflect.ValueOf(base64.StdEncoding.EncodeToString(content)), nil
-			}
-		} else {
-			if filename, ok := strings.CutPrefix(s, "@"); ok {
-				// Behavior is the same for @file, @data://file, and @file://file, except that
-				// @username will be treated as a literal string if no "username" file exists
-				expectsFile := true
-				if withoutPrefix, ok := strings.CutPrefix(filename, "data://"); ok {
-					filename = withoutPrefix
-				} else if withoutPrefix, ok := strings.CutPrefix(filename, "file://"); ok {
-					filename = withoutPrefix
-				} else {
-					expectsFile = strings.Contains(filename, ".") || strings.Contains(filename, "/")
-				}
-
-				file, err := os.Open(filename)
-				if err != nil {
-					if !expectsFile {
-						// For strings that start with "@" and don't look like a filename, return the string
-						return v, nil
-					}
-					return v, err
-				}
-				return reflect.ValueOf(file), nil
-			}
-		}
-		return v, nil
-
-	default:
-		return v, nil
-	}
-}
-
-// Guess whether a file's contents are binary (e.g. a .jpg or .mp3), as opposed
-// to plain text (e.g. .txt or .md).
-func isUTF8TextFile(content []byte) bool {
-	// Go's DetectContentType follows https://mimesniff.spec.whatwg.org/ and
-	// these are the sniffable content types that are plain text:
-	textTypes := []string{
-		"text/",
-		"application/json",
-		"application/xml",
-		"application/javascript",
-		"application/x-javascript",
-		"application/ecmascript",
-		"application/x-ecmascript",
-	}
-
-	contentType := http.DetectContentType(content)
-	for _, prefix := range textTypes {
-		if strings.HasPrefix(contentType, prefix) {
-			return utf8.Valid(content)
-		}
-	}
-	return false
-}
-
-func flagOptions(
-	cmd *cli.Command,
-	nestedFormat apiquery.NestedQueryFormat,
-	arrayFormat apiquery.ArrayQueryFormat,
-	bodyType BodyContentType,
-
-	// This parameter is true if stdin is already in use to pass a binary parameter by using the special value
-	// "-". In this case, we won't attempt to read it as a JSON/YAML blob for options setting.
-	ignoreStdin bool,
-) ([]option.RequestOption, error) {
-	var options []option.RequestOption
-	if cmd.Bool("debug") {
-		options = append(options, option.WithMiddleware(debugmiddleware.NewRequestLogger().Middleware()))
-	}
-
-	requestContents := requestflag.ExtractRequestContents(cmd)
-
-	if (bodyType == MultipartFormEncoded || bodyType == ApplicationJSON) && !ignoreStdin && isInputPiped() {
-		pipeData, err := io.ReadAll(os.Stdin)
-		if err != nil {
-			return nil, err
-		}
-
-		if len(pipeData) > 0 {
-			var bodyData any
-			if err := yaml.Unmarshal(pipeData, &bodyData); err != nil {
-				return nil, fmt.Errorf("Failed to parse piped data as YAML/JSON:\n%w", err)
-			}
-			if bodyMap, ok := bodyData.(map[string]any); ok {
-				if flagMap, ok := requestContents.Body.(map[string]any); ok {
-					maps.Copy(bodyMap, flagMap)
-					requestContents.Body = bodyMap
-				} else {
-					bodyData = requestContents.Body
-				}
-			} else if flagMap, ok := requestContents.Body.(map[string]any); ok && len(flagMap) > 0 {
-				return nil, fmt.Errorf("Cannot merge flags with a body that is not a map: %v", bodyData)
-			} else {
-				requestContents.Body = bodyData
-			}
-		}
-	}
-
-	if missingFlags := requestflag.GetMissingRequiredFlags(cmd, requestContents.Body); len(missingFlags) > 0 {
-		var buf bytes.Buffer
-		cli.HelpPrinter(&buf, cli.SubcommandHelpTemplate, cmd)
-		usage := buf.String()
-		if len(missingFlags) == 1 {
-			return nil, fmt.Errorf("%sRequired flag %q not set", usage, missingFlags[0].Names()[0])
-		} else {
-			names := []string{}
-			for _, flag := range missingFlags {
-				names = append(names, flag.Names()[0])
-			}
-			return nil, fmt.Errorf("%sRequired flags %q not set", usage, strings.Join(names, ", "))
-		}
-	}
-
-	// Embed files passed as "@file.jpg" in the request body, headers, and query:
-	embedStyle := EmbedText
-	if bodyType == ApplicationOctetStream || bodyType == MultipartFormEncoded {
-		embedStyle = EmbedIOReader
-	}
-
-	if embedded, err := embedFiles(requestContents.Body, embedStyle); err != nil {
-		return nil, err
-	} else {
-		requestContents.Body = embedded
-	}
-
-	if headersWithFiles, err := embedFiles(requestContents.Headers, EmbedText); err != nil {
-		return nil, err
-	} else {
-		requestContents.Headers = headersWithFiles.(map[string]any)
-	}
-	if queriesWithFiles, err := embedFiles(requestContents.Queries, EmbedText); err != nil {
-		return nil, err
-	} else {
-		requestContents.Queries = queriesWithFiles.(map[string]any)
-	}
-
-	querySettings := apiquery.QuerySettings{
-		NestedFormat: nestedFormat,
-		ArrayFormat:  arrayFormat,
-	}
-
-	// Add query parameters:
-	if values, err := apiquery.MarshalWithSettings(requestContents.Queries, querySettings); err != nil {
-		return nil, err
-	} else {
-		for k, vs := range values {
-			if len(vs) == 0 {
-				options = append(options, option.WithQueryDel(k))
-			} else {
-				options = append(options, option.WithQuery(k, vs[0]))
-				for _, v := range vs[1:] {
-					options = append(options, option.WithQueryAdd(k, v))
-				}
-			}
-		}
-	}
-
-	// Add header parameters
-	headerSettings := apiquery.QuerySettings{
-		NestedFormat: apiquery.NestedQueryFormatDots,
-		ArrayFormat:  apiquery.ArrayQueryFormatRepeat,
-	}
-	if values, err := apiquery.MarshalWithSettings(requestContents.Headers, headerSettings); err != nil {
-		return nil, err
-	} else {
-		for k, vs := range values {
-			if len(vs) == 0 {
-				options = append(options, option.WithHeaderDel(k))
-			} else {
-				options = append(options, option.WithHeader(k, vs[0]))
-				for _, v := range vs[1:] {
-					options = append(options, option.WithHeaderAdd(k, v))
-				}
-			}
-		}
-	}
-
-	switch bodyType {
-	case EmptyBody:
-		break
-	case MultipartFormEncoded:
-		buf := new(bytes.Buffer)
-		writer := multipart.NewWriter(buf)
-
-		// For multipart/form-encoded, we need a map structure
-		bodyMap, ok := requestContents.Body.(map[string]any)
-		if !ok {
-			return nil, fmt.Errorf("Cannot send a non-map value to a form-encoded endpoint: %v\n", requestContents.Body)
-		}
-		encodingFormat := apiform.FormatRepeat
-		if err := apiform.MarshalWithSettings(bodyMap, writer, encodingFormat); err != nil {
-			return nil, err
-		}
-		if err := writer.Close(); err != nil {
-			return nil, err
-		}
-		options = append(options, option.WithRequestBody(writer.FormDataContentType(), buf))
-
-	case ApplicationJSON:
-		bodyBytes, err := json.Marshal(requestContents.Body)
-		if err != nil {
-			return nil, err
-		}
-		options = append(options, option.WithRequestBody("application/json", bodyBytes))
-
-	case ApplicationOctetStream:
-		// If there is a body root parameter, that will handle setting the request body, we don't need to do it here.
-		for _, flag := range cmd.Flags {
-			if toSend, ok := flag.(requestflag.InRequest); ok && toSend.IsBodyRoot() {
-				return options, nil
-			}
-		}
-		if bodyBytes, ok := requestContents.Body.([]byte); ok {
-			options = append(options, option.WithRequestBody("application/octet-stream", bodyBytes))
-		} else if bodyStr, ok := requestContents.Body.(string); ok {
-			options = append(options, option.WithRequestBody("application/octet-stream", []byte(bodyStr)))
-		} else {
-			return nil, fmt.Errorf("Unsupported body for application/octet-stream: %v", requestContents.Body)
-		}
-
-	default:
-		panic("Invalid body content type!")
-	}
-
-	return options, nil
-}
diff --git a/pkg/cmd/flagoptions_test.go b/pkg/cmd/flagoptions_test.go
deleted file mode 100644
index e5dad4b..0000000
--- a/pkg/cmd/flagoptions_test.go
+++ /dev/null
@@ -1,244 +0,0 @@
-package cmd
-
-import (
-	"encoding/base64"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestIsUTF8TextFile(t *testing.T) {
-	tests := []struct {
-		content  []byte
-		expected bool
-	}{
-		{[]byte("Hello, world!"), true},
-		{[]byte(`{"key": "value"}`), true},
-		{[]byte(`<?xml version="1.0"?><root/>`), true},
-		{[]byte(`function test() {}`), true},
-		{[]byte{0xFF, 0xD8, 0xFF, 0xE0}, false}, // JPEG header
-		{[]byte{0x00, 0x01, 0xFF, 0xFE}, false}, // binary
-		{[]byte("Hello \xFF\xFE"), false},       // invalid UTF-8
-		{[]byte("Hello ☺️"), true},              // emoji
-		{[]byte{}, true},                        // empty
-	}
-
-	for _, tt := range tests {
-		assert.Equal(t, tt.expected, isUTF8TextFile(tt.content))
-	}
-}
-
-func TestEmbedFiles(t *testing.T) {
-	// Create temporary directory for test files
-	tmpDir := t.TempDir()
-
-	// Create test files
-	configContent := "host=localhost\nport=8080"
-	templateContent := "<html><body>Hello</body></html>"
-	dataContent := `{"key": "value"}`
-
-	writeTestFile(t, tmpDir, "config.txt", configContent)
-	writeTestFile(t, tmpDir, "template.html", templateContent)
-	writeTestFile(t, tmpDir, "data.json", dataContent)
-	jpegHeader := []byte{0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46, 0x49, 0x46}
-	writeTestFile(t, tmpDir, "image.jpg", string(jpegHeader))
-
-	tests := []struct {
-		name    string
-		input   any
-		want    any
-		wantErr bool
-	}{
-		{
-			name: "map[string]any with file references",
-			input: map[string]any{
-				"config":   "@" + filepath.Join(tmpDir, "config.txt"),
-				"template": "@file://" + filepath.Join(tmpDir, "template.html"),
-				"count":    42,
-			},
-			want: map[string]any{
-				"config":   configContent,
-				"template": templateContent,
-				"count":    42,
-			},
-			wantErr: false,
-		},
-		{
-			name: "map[string]string with file references",
-			input: map[string]any{
-				"config": "@" + filepath.Join(tmpDir, "config.txt"),
-				"name":   "test",
-			},
-			want: map[string]any{
-				"config": configContent,
-				"name":   "test",
-			},
-			wantErr: false,
-		},
-		{
-			name: "[]any with file references",
-			input: []any{
-				"@" + filepath.Join(tmpDir, "config.txt"),
-				42,
-				true,
-				"@file://" + filepath.Join(tmpDir, "data.json"),
-			},
-			want: []any{
-				configContent,
-				42,
-				true,
-				dataContent,
-			},
-			wantErr: false,
-		},
-		{
-			name: "[]string with file references",
-			input: []any{
-				"@" + filepath.Join(tmpDir, "config.txt"),
-				"normal string",
-			},
-			want: []any{
-				configContent,
-				"normal string",
-			},
-			wantErr: false,
-		},
-		{
-			name: "nested structures",
-			input: map[string]any{
-				"outer": map[string]any{
-					"inner": []any{
-						"@" + filepath.Join(tmpDir, "config.txt"),
-						map[string]any{
-							"data": "@" + filepath.Join(tmpDir, "data.json"),
-						},
-					},
-				},
-			},
-			want: map[string]any{
-				"outer": map[string]any{
-					"inner": []any{
-						configContent,
-						map[string]any{
-							"data": dataContent,
-						},
-					},
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "base64 encoding",
-			input: map[string]any{
-				"encoded": "@data://" + filepath.Join(tmpDir, "config.txt"),
-				"image":   "@" + filepath.Join(tmpDir, "image.jpg"),
-			},
-			want: map[string]any{
-				"encoded": base64.StdEncoding.EncodeToString([]byte(configContent)),
-				"image":   base64.StdEncoding.EncodeToString(jpegHeader),
-			},
-			wantErr: false,
-		},
-		{
-			name: "non-existent file with @ prefix",
-			input: map[string]any{
-				"missing": "@file.txt",
-			},
-			want:    nil,
-			wantErr: true,
-		},
-		{
-			name: "non-file-like thing with @ prefix",
-			input: map[string]any{
-				"username":        "@user",
-				"favorite_symbol": "@",
-			},
-			want: map[string]any{
-				"username":        "@user",
-				"favorite_symbol": "@",
-			},
-			wantErr: false,
-		},
-		{
-			name: "non-existent file with @file:// prefix (error)",
-			input: map[string]any{
-				"missing": "@file:///nonexistent/file.txt",
-			},
-			want:    nil,
-			wantErr: true,
-		},
-		{
-			name: "escaping",
-			input: map[string]any{
-				"simple":      "\\@file.txt",
-				"file":        "\\@file://file.txt",
-				"data":        "\\@data://file.txt",
-				"keep_escape": "user\\@example.com",
-			},
-			want: map[string]any{
-				"simple":      "@file.txt",
-				"file":        "@file://file.txt",
-				"data":        "@data://file.txt",
-				"keep_escape": "user\\@example.com",
-			},
-			wantErr: false,
-		},
-		{
-			name: "primitive types",
-			input: map[string]any{
-				"int":    123,
-				"float":  45.67,
-				"bool":   true,
-				"null":   nil,
-				"string": "no prefix",
-				"email":  "user@example.com",
-			},
-			want: map[string]any{
-				"int":    123,
-				"float":  45.67,
-				"bool":   true,
-				"null":   nil,
-				"string": "no prefix",
-				"email":  "user@example.com",
-			},
-			wantErr: false,
-		},
-		{
-			name:    "[]int values unchanged",
-			input:   []int{1, 2, 3, 4, 5},
-			want:    []any{1, 2, 3, 4, 5},
-			wantErr: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name+" text", func(t *testing.T) {
-			got, err := embedFiles(tt.input, EmbedText)
-			if tt.wantErr {
-				assert.Error(t, err)
-			} else {
-				require.NoError(t, err)
-				assert.Equal(t, tt.want, got)
-			}
-		})
-
-		t.Run(tt.name+" io.Reader", func(t *testing.T) {
-			_, err := embedFiles(tt.input, EmbedIOReader)
-			if tt.wantErr {
-				assert.Error(t, err)
-			} else {
-				require.NoError(t, err)
-			}
-		})
-	}
-}
-
-func writeTestFile(t *testing.T, dir, filename, content string) {
-	t.Helper()
-	path := filepath.Join(dir, filename)
-	err := os.WriteFile(path, []byte(content), 0644)
-	require.NoError(t, err, "failed to write test file %s", path)
-}
diff --git a/pkg/cmd/info.go b/pkg/cmd/info.go
deleted file mode 100644
index 2b46d49..0000000
--- a/pkg/cmd/info.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/beeper/desktop-api-cli/internal/apiquery"
-	"github.com/beeper/desktop-api-go"
-	"github.com/beeper/desktop-api-go/option"
-	"github.com/tidwall/gjson"
-	"github.com/urfave/cli/v3"
-)
-
-var infoRetrieve = cli.Command{
-	Name:            "retrieve",
-	Usage:           "Returns app, platform, server, and endpoint discovery metadata for this Beeper\nDesktop instance.",
-	Suggest:         true,
-	Flags:           []cli.Flag{},
-	Action:          handleInfoRetrieve,
-	HideHelpCommand: true,
-}
-
-func handleInfoRetrieve(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Info.Get(ctx, options...)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "info retrieve", obj, format, transform)
-}
diff --git a/pkg/cmd/info_test.go b/pkg/cmd/info_test.go
deleted file mode 100644
index 507d04e..0000000
--- a/pkg/cmd/info_test.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"testing"
-
-	"github.com/beeper/desktop-api-cli/internal/mocktest"
-)
-
-func TestInfoRetrieve(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"info", "retrieve",
-		)
-	})
-}
diff --git a/pkg/cmd/message.go b/pkg/cmd/message.go
deleted file mode 100644
index b65cef7..0000000
--- a/pkg/cmd/message.go
+++ /dev/null
@@ -1,398 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/beeper/desktop-api-cli/internal/apiquery"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-	"github.com/beeper/desktop-api-go"
-	"github.com/beeper/desktop-api-go/option"
-	"github.com/tidwall/gjson"
-	"github.com/urfave/cli/v3"
-)
-
-var messagesUpdate = cli.Command{
-	Name:    "update",
-	Usage:   "Edit the text content of an existing message. Messages with attachments cannot\nbe edited.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "chat-id",
-			Usage:    "Unique identifier of the chat.",
-			Required: true,
-		},
-		&requestflag.Flag[string]{
-			Name:     "message-id",
-			Required: true,
-		},
-		&requestflag.Flag[string]{
-			Name:     "text",
-			Usage:    "New text content for the message",
-			Required: true,
-			BodyPath: "text",
-		},
-	},
-	Action:          handleMessagesUpdate,
-	HideHelpCommand: true,
-}
-
-var messagesList = cli.Command{
-	Name:    "list",
-	Usage:   "List all messages in a chat with cursor-based pagination. Sorted by timestamp.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "chat-id",
-			Usage:    "Unique identifier of the chat.",
-			Required: true,
-		},
-		&requestflag.Flag[string]{
-			Name:      "cursor",
-			Usage:     "Opaque pagination cursor; do not inspect. Use together with 'direction'.",
-			QueryPath: "cursor",
-		},
-		&requestflag.Flag[string]{
-			Name:      "direction",
-			Usage:     "Pagination direction used with 'cursor': 'before' fetches older results, 'after' fetches newer results. Defaults to 'before' when only 'cursor' is provided.",
-			QueryPath: "direction",
-		},
-		&requestflag.Flag[int64]{
-			Name:  "max-items",
-			Usage: "The maximum number of items to return (use -1 for unlimited).",
-		},
-	},
-	Action:          handleMessagesList,
-	HideHelpCommand: true,
-}
-
-var messagesSearch = cli.Command{
-	Name:    "search",
-	Usage:   "Search messages across chats using Beeper's message index",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[[]string]{
-			Name:      "account-id",
-			Usage:     "Limit search to specific account IDs.",
-			QueryPath: "accountIDs",
-		},
-		&requestflag.Flag[[]string]{
-			Name:      "chat-id",
-			Usage:     "Limit search to specific chat IDs.",
-			QueryPath: "chatIDs",
-		},
-		&requestflag.Flag[string]{
-			Name:      "chat-type",
-			Usage:     "Filter by chat type: 'group' for group chats, 'single' for 1:1 chats.",
-			QueryPath: "chatType",
-		},
-		&requestflag.Flag[string]{
-			Name:      "cursor",
-			Usage:     "Opaque pagination cursor; do not inspect. Use together with 'direction'.",
-			QueryPath: "cursor",
-		},
-		&requestflag.Flag[any]{
-			Name:      "date-after",
-			Usage:     "Only include messages with timestamp strictly after this ISO 8601 datetime (e.g., '2024-07-01T00:00:00Z' or '2024-07-01T00:00:00+02:00').",
-			QueryPath: "dateAfter",
-		},
-		&requestflag.Flag[any]{
-			Name:      "date-before",
-			Usage:     "Only include messages with timestamp strictly before this ISO 8601 datetime (e.g., '2024-07-31T23:59:59Z' or '2024-07-31T23:59:59+02:00').",
-			QueryPath: "dateBefore",
-		},
-		&requestflag.Flag[string]{
-			Name:      "direction",
-			Usage:     "Pagination direction used with 'cursor': 'before' fetches older results, 'after' fetches newer results. Defaults to 'before' when only 'cursor' is provided.",
-			QueryPath: "direction",
-		},
-		&requestflag.Flag[any]{
-			Name:      "exclude-low-priority",
-			Usage:     "Exclude messages marked Low Priority by the user. Default: true. Set to false to include all.",
-			Default:   true,
-			QueryPath: "excludeLowPriority",
-		},
-		&requestflag.Flag[any]{
-			Name:      "include-muted",
-			Usage:     "Include messages in chats marked as Muted by the user, which are usually less important. Default: true. Set to false if the user wants a more refined search.",
-			Default:   true,
-			QueryPath: "includeMuted",
-		},
-		&requestflag.Flag[int64]{
-			Name:      "limit",
-			Usage:     "Maximum number of messages to return.",
-			Default:   20,
-			QueryPath: "limit",
-		},
-		&requestflag.Flag[[]string]{
-			Name:      "media-type",
-			Usage:     "Filter messages by media types. Use ['any'] for any media type, or specify exact types like ['video', 'image']. Omit for no media filtering.",
-			QueryPath: "mediaTypes",
-		},
-		&requestflag.Flag[string]{
-			Name:      "query",
-			Usage:     `Literal word search (non-semantic). Finds messages containing these EXACT words in any order. Use single words users actually type, not concepts or phrases. Example: use "dinner" not "dinner plans", use "sick" not "health issues". If omitted, returns results filtered only by other parameters.`,
-			QueryPath: "query",
-		},
-		&requestflag.Flag[string]{
-			Name:      "sender",
-			Usage:     "Filter by sender: 'me' (messages sent by the authenticated user), 'others' (messages sent by others), or a specific user ID string (user.id).",
-			QueryPath: "sender",
-		},
-		&requestflag.Flag[int64]{
-			Name:  "max-items",
-			Usage: "The maximum number of items to return (use -1 for unlimited).",
-		},
-	},
-	Action:          handleMessagesSearch,
-	HideHelpCommand: true,
-}
-
-var messagesSend = requestflag.WithInnerFlags(cli.Command{
-	Name:    "send",
-	Usage:   "Send a text message to a specific chat. Supports replying to existing messages.\nReturns a pending message ID.",
-	Suggest: true,
-	Flags: []cli.Flag{
-		&requestflag.Flag[string]{
-			Name:     "chat-id",
-			Usage:    "Unique identifier of the chat.",
-			Required: true,
-		},
-		&requestflag.Flag[map[string]any]{
-			Name:     "attachment",
-			Usage:    "Single attachment to send with the message",
-			BodyPath: "attachment",
-		},
-		&requestflag.Flag[string]{
-			Name:     "reply-to-message-id",
-			Usage:    "Provide a message ID to send this as a reply to an existing message",
-			BodyPath: "replyToMessageID",
-		},
-		&requestflag.Flag[string]{
-			Name:     "text",
-			Usage:    "Text content of the message you want to send. You may use markdown.",
-			BodyPath: "text",
-		},
-	},
-	Action:          handleMessagesSend,
-	HideHelpCommand: true,
-}, map[string][]requestflag.HasOuterFlag{
-	"attachment": {
-		&requestflag.InnerFlag[string]{
-			Name:       "attachment.upload-id",
-			Usage:      "Upload ID from uploadAsset endpoint. Required to reference uploaded files.",
-			InnerField: "uploadID",
-		},
-		&requestflag.InnerFlag[float64]{
-			Name:       "attachment.duration",
-			Usage:      "Duration in seconds (optional override of cached value)",
-			InnerField: "duration",
-		},
-		&requestflag.InnerFlag[string]{
-			Name:       "attachment.file-name",
-			Usage:      "Filename (optional override of cached value)",
-			InnerField: "fileName",
-		},
-		&requestflag.InnerFlag[string]{
-			Name:       "attachment.mime-type",
-			Usage:      "MIME type (optional override of cached value)",
-			InnerField: "mimeType",
-		},
-		&requestflag.InnerFlag[map[string]any]{
-			Name:       "attachment.size",
-			Usage:      "Dimensions (optional override of cached value)",
-			InnerField: "size",
-		},
-		&requestflag.InnerFlag[string]{
-			Name:       "attachment.type",
-			Usage:      "Special attachment type (gif, voiceNote, sticker). If omitted, auto-detected from mimeType",
-			InnerField: "type",
-		},
-	},
-})
-
-func handleMessagesUpdate(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-	if !cmd.IsSet("message-id") && len(unusedArgs) > 0 {
-		cmd.Set("message-id", unusedArgs[0])
-		unusedArgs = unusedArgs[1:]
-	}
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.MessageUpdateParams{
-		ChatID: cmd.Value("chat-id").(string),
-	}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		ApplicationJSON,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Messages.Update(
-		ctx,
-		cmd.Value("message-id").(string),
-		params,
-		options...,
-	)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "messages update", obj, format, transform)
-}
-
-func handleMessagesList(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-	if !cmd.IsSet("chat-id") && len(unusedArgs) > 0 {
-		cmd.Set("chat-id", unusedArgs[0])
-		unusedArgs = unusedArgs[1:]
-	}
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.MessageListParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	if format == "raw" {
-		var res []byte
-		options = append(options, option.WithResponseBodyInto(&res))
-		_, err = client.Messages.List(
-			ctx,
-			cmd.Value("chat-id").(string),
-			params,
-			options...,
-		)
-		if err != nil {
-			return err
-		}
-		obj := gjson.ParseBytes(res)
-		return ShowJSON(os.Stdout, "messages list", obj, format, transform)
-	} else {
-		iter := client.Messages.ListAutoPaging(
-			ctx,
-			cmd.Value("chat-id").(string),
-			params,
-			options...,
-		)
-		maxItems := int64(-1)
-		if cmd.IsSet("max-items") {
-			maxItems = cmd.Value("max-items").(int64)
-		}
-		return ShowJSONIterator(os.Stdout, "messages list", iter, format, transform, maxItems)
-	}
-}
-
-func handleMessagesSearch(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.MessageSearchParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		EmptyBody,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	if format == "raw" {
-		var res []byte
-		options = append(options, option.WithResponseBodyInto(&res))
-		_, err = client.Messages.Search(ctx, params, options...)
-		if err != nil {
-			return err
-		}
-		obj := gjson.ParseBytes(res)
-		return ShowJSON(os.Stdout, "messages search", obj, format, transform)
-	} else {
-		iter := client.Messages.SearchAutoPaging(ctx, params, options...)
-		maxItems := int64(-1)
-		if cmd.IsSet("max-items") {
-			maxItems = cmd.Value("max-items").(int64)
-		}
-		return ShowJSONIterator(os.Stdout, "messages search", iter, format, transform, maxItems)
-	}
-}
-
-func handleMessagesSend(ctx context.Context, cmd *cli.Command) error {
-	client := beeperdesktopapi.NewClient(getDefaultRequestOptions(cmd)...)
-	unusedArgs := cmd.Args().Slice()
-	if !cmd.IsSet("chat-id") && len(unusedArgs) > 0 {
-		cmd.Set("chat-id", unusedArgs[0])
-		unusedArgs = unusedArgs[1:]
-	}
-	if len(unusedArgs) > 0 {
-		return fmt.Errorf("Unexpected extra arguments: %v", unusedArgs)
-	}
-
-	params := beeperdesktopapi.MessageSendParams{}
-
-	options, err := flagOptions(
-		cmd,
-		apiquery.NestedQueryFormatBrackets,
-		apiquery.ArrayQueryFormatRepeat,
-		ApplicationJSON,
-		false,
-	)
-	if err != nil {
-		return err
-	}
-
-	var res []byte
-	options = append(options, option.WithResponseBodyInto(&res))
-	_, err = client.Messages.Send(
-		ctx,
-		cmd.Value("chat-id").(string),
-		params,
-		options...,
-	)
-	if err != nil {
-		return err
-	}
-
-	obj := gjson.ParseBytes(res)
-	format := cmd.Root().String("format")
-	transform := cmd.Root().String("transform")
-	return ShowJSON(os.Stdout, "messages send", obj, format, transform)
-}
diff --git a/pkg/cmd/message_test.go b/pkg/cmd/message_test.go
deleted file mode 100644
index 11fe9a2..0000000
--- a/pkg/cmd/message_test.go
+++ /dev/null
@@ -1,132 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-import (
-	"testing"
-
-	"github.com/beeper/desktop-api-cli/internal/mocktest"
-	"github.com/beeper/desktop-api-cli/internal/requestflag"
-)
-
-func TestMessagesUpdate(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"messages", "update",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--message-id", "messageID",
-			"--text", "x",
-		)
-	})
-
-	t.Run("piping data", func(t *testing.T) {
-		// Test piping YAML data over stdin
-		pipeData := []byte("text: x")
-		mocktest.TestRunMockTestWithPipeAndFlags(
-			t, pipeData,
-			"--access-token", "string",
-			"messages", "update",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--message-id", "messageID",
-		)
-	})
-}
-
-func TestMessagesList(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"messages", "list",
-			"--max-items", "10",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--cursor", "1725489123456|c29tZUltc2dQYWdl",
-			"--direction", "before",
-		)
-	})
-}
-
-func TestMessagesSearch(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"messages", "search",
-			"--max-items", "10",
-			"--account-id", "local-whatsapp_ba_EvYDBBsZbRQAy3UOSWqG0LuTVkc",
-			"--account-id", "local-instagram_ba_eRfQMmnSNy_p7Ih7HL7RduRpKFU",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--chat-id", "1231073",
-			"--chat-type", "group",
-			"--cursor", "1725489123456|c29tZUltc2dQYWdl",
-			"--date-after", "'2025-08-01T00:00:00Z'",
-			"--date-before", "'2025-08-31T23:59:59Z'",
-			"--direction", "before",
-			"--exclude-low-priority=true",
-			"--include-muted=true",
-			"--limit", "20",
-			"--media-type", "any",
-			"--query", "dinner",
-			"--sender", "sender",
-		)
-	})
-}
-
-func TestMessagesSend(t *testing.T) {
-	t.Run("regular flags", func(t *testing.T) {
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"messages", "send",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--attachment", "{uploadID: uploadID, duration: 0, fileName: fileName, mimeType: mimeType, size: {height: 0, width: 0}, type: gif}",
-			"--reply-to-message-id", "replyToMessageID",
-			"--text", "text",
-		)
-	})
-
-	t.Run("inner flags", func(t *testing.T) {
-		// Check that inner flags have been set up correctly
-		requestflag.CheckInnerFlags(messagesSend)
-
-		// Alternative argument passing style using inner flags
-		mocktest.TestRunMockTestWithFlags(
-			t,
-			"--access-token", "string",
-			"messages", "send",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-			"--attachment.upload-id", "uploadID",
-			"--attachment.duration", "0",
-			"--attachment.file-name", "fileName",
-			"--attachment.mime-type", "mimeType",
-			"--attachment.size", "{height: 0, width: 0}",
-			"--attachment.type", "gif",
-			"--reply-to-message-id", "replyToMessageID",
-			"--text", "text",
-		)
-	})
-
-	t.Run("piping data", func(t *testing.T) {
-		// Test piping YAML data over stdin
-		pipeData := []byte("" +
-			"attachment:\n" +
-			"  uploadID: uploadID\n" +
-			"  duration: 0\n" +
-			"  fileName: fileName\n" +
-			"  mimeType: mimeType\n" +
-			"  size:\n" +
-			"    height: 0\n" +
-			"    width: 0\n" +
-			"  type: gif\n" +
-			"replyToMessageID: replyToMessageID\n" +
-			"text: text\n")
-		mocktest.TestRunMockTestWithPipeAndFlags(
-			t, pipeData,
-			"--access-token", "string",
-			"messages", "send",
-			"--chat-id", "!NCdzlIaMjZUmvmvyHU:beeper.com",
-		)
-	})
-}
diff --git a/pkg/cmd/suggest.go b/pkg/cmd/suggest.go
deleted file mode 100644
index b4b637c..0000000
--- a/pkg/cmd/suggest.go
+++ /dev/null
@@ -1,126 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"math"
-	"slices"
-	"strings"
-
-	"github.com/urfave/cli/v3"
-)
-
-// This entire file is mostly taken from urfave/cli/v3's source, with the exception of suggestCommand which is
-// modified for a nicer error message.
-
-// jaroDistance is the measure of similarity between two strings. It returns a
-// value between 0 and 1, where 1 indicates identical strings and 0 indicates
-// completely different strings.
-//
-// Adapted from https://github.com/xrash/smetrics/blob/5f08fbb34913bc8ab95bb4f2a89a0637ca922666/jaro.go.
-func jaroDistance(a, b string) float64 {
-	if len(a) == 0 && len(b) == 0 {
-		return 1
-	}
-	if len(a) == 0 || len(b) == 0 {
-		return 0
-	}
-
-	lenA := float64(len(a))
-	lenB := float64(len(b))
-	hashA := make([]bool, len(a))
-	hashB := make([]bool, len(b))
-	maxDistance := int(math.Max(0, math.Floor(math.Max(lenA, lenB)/2.0)-1))
-
-	var matches float64
-	for i := 0; i < len(a); i++ {
-		start := int(math.Max(0, float64(i-maxDistance)))
-		end := int(math.Min(lenB-1, float64(i+maxDistance)))
-
-		for j := start; j <= end; j++ {
-			if hashB[j] {
-				continue
-			}
-			if a[i] == b[j] {
-				hashA[i] = true
-				hashB[j] = true
-				matches++
-				break
-			}
-		}
-	}
-	if matches == 0 {
-		return 0
-	}
-
-	var transpositions float64
-	var j int
-	for i := 0; i < len(a); i++ {
-		if !hashA[i] {
-			continue
-		}
-		for !hashB[j] {
-			j++
-		}
-		if a[i] != b[j] {
-			transpositions++
-		}
-		j++
-	}
-
-	transpositions /= 2
-	return ((matches / lenA) + (matches / lenB) + ((matches - transpositions) / matches)) / 3.0
-}
-
-// jaroWinkler is more accurate when strings have a common prefix up to a
-// defined maximum length.
-//
-// Adapted from https://github.com/xrash/smetrics/blob/5f08fbb34913bc8ab95bb4f2a89a0637ca922666/jaro-winkler.go.
-func jaroWinkler(a, b string) float64 {
-	const (
-		boostThreshold = 0.7
-		prefixSize     = 4
-	)
-	jaroDist := jaroDistance(a, b)
-	if jaroDist <= boostThreshold {
-		return jaroDist
-	}
-
-	prefix := int(math.Min(float64(len(a)), math.Min(float64(prefixSize), float64(len(b)))))
-
-	var prefixMatch float64
-	for i := 0; i < prefix; i++ {
-		if a[i] == b[i] {
-			prefixMatch++
-		} else {
-			break
-		}
-	}
-	return jaroDist + 0.1*prefixMatch*(1.0-jaroDist)
-}
-
-// suggestCommand takes a list of commands and a provided string to suggest a
-// command name
-func suggestCommand(commands []*cli.Command, provided string) string {
-	distance := 0.0
-	var lineage []*cli.Command
-	for _, command := range commands {
-		for _, name := range command.Names() {
-			newDistance := jaroWinkler(name, provided)
-			if newDistance > distance {
-				distance = newDistance
-				lineage = command.Lineage()
-			}
-		}
-	}
-
-	var parts []string
-	for _, command := range lineage {
-		parts = append(parts, command.Name)
-	}
-	slices.Reverse(parts)
-	return fmt.Sprintf("Did you mean '%s'?", strings.Join(parts, " "))
-}
-
-func init() {
-	cli.SuggestCommand = suggestCommand
-}
diff --git a/pkg/cmd/version.go b/pkg/cmd/version.go
deleted file mode 100644
index 5266c84..0000000
--- a/pkg/cmd/version.go
+++ /dev/null
@@ -1,5 +0,0 @@
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-package cmd
-
-const Version = "0.3.0" // x-release-please-version
diff --git a/release-please-config.json b/release-please-config.json
index 53619de..0eec94e 100644
--- a/release-please-config.json
+++ b/release-please-config.json
@@ -61,7 +61,7 @@
   ],
   "release-type": "simple",
   "extra-files": [
-    "pkg/cmd/version.go",
+    "package.json",
     "README.md"
   ]
-}
\ No newline at end of file
+}
diff --git a/scripts/bootstrap b/scripts/bootstrap
index 9ebb7d3..2baee40 100755
--- a/scripts/bootstrap
+++ b/scripts/bootstrap
@@ -18,5 +18,8 @@ if [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ] && [ "$SKIP_BREW" != "1" ]
     echo
   }
 fi
-echo "==> Installing Go dependencies…"
-go mod tidy -e || true
+echo "==> Checking Node dependencies"
+if [ ! -d node_modules ]; then
+  echo "node_modules is missing. Run npm install after approving dependency installation."
+  exit 1
+fi
diff --git a/scripts/build b/scripts/build
index 7eb0308..a1c560f 100755
--- a/scripts/build
+++ b/scripts/build
@@ -4,8 +4,5 @@ set -euo pipefail
 
 cd "$(dirname "$0")/.."
 
-# Mark the necessary Go modules as private to avoid Go's proxy
-export GOPRIVATE="${GOPRIVATE:+$GOPRIVATE,}github.com/beeper/desktop-api-go,github.com/stainless-sdks/beeper-desktop-api-go"
-
-echo "==> Building beeper-desktop-cli"
-go build ./cmd/beeper-desktop-cli
+echo "==> Building Beeper CLI"
+npm run build
diff --git a/scripts/build-homebrew-archive.mjs b/scripts/build-homebrew-archive.mjs
new file mode 100644
index 0000000..4c8ceef
--- /dev/null
+++ b/scripts/build-homebrew-archive.mjs
@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import {createHash} from 'node:crypto';
+import {existsSync} from 'node:fs';
+import {cp, mkdir, mkdtemp, readFile, rm, stat, writeFile} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {basename, join, resolve} from 'node:path';
+import {spawn} from 'node:child_process';
+
+const root = resolve(new URL('..', import.meta.url).pathname);
+const packageJsonPath = join(root, 'package.json');
+const packageLockPath = join(root, 'package-lock.json');
+const distPath = join(root, 'dist');
+const outDir = join(root, 'dist', 'release');
+
+const pkg = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+const packageName = 'beeper-cli';
+const commandName = 'beeper';
+const version = process.env.PACKAGE_VERSION || pkg.version;
+const archiveName = `${packageName}_${version}_any.tar.gz`;
+const archivePath = join(outDir, archiveName);
+const metadataPath = join(outDir, 'homebrew.json');
+const workDir = await mkdtemp(join(tmpdir(), 'beeper-cli-homebrew-'));
+
+await ensureBuilt();
+await mkdir(join(workDir, 'bin'), {recursive: true});
+await mkdir(join(workDir, 'libexec'), {recursive: true});
+await mkdir(outDir, {recursive: true});
+
+await cp(packageJsonPath, join(workDir, 'libexec', 'package.json'));
+await cp(packageLockPath, join(workDir, 'libexec', 'package-lock.json'));
+await cp(join(root, 'bin'), join(workDir, 'libexec', 'bin'), {recursive: true});
+await cp(distPath, join(workDir, 'libexec', 'dist'), {
+  recursive: true,
+  filter: source => !source.startsWith(outDir),
+});
+await writeFile(
+  join(workDir, 'bin', commandName),
+  `#!/bin/sh
+set -e
+prefix="$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)"
+exec node "$prefix/libexec/bin/run.js" "$@"
+`,
+  {mode: 0o755},
+);
+
+await run('npm', ['ci', '--omit=dev', '--ignore-scripts', '--no-audit', '--no-fund'], {
+  cwd: join(workDir, 'libexec'),
+});
+await rm(archivePath, {force: true});
+await run('tar', ['-czf', archivePath, '-C', workDir, '.'], {cwd: root});
+
+const sha256 = await hashFile(archivePath);
+await writeFile(
+  metadataPath,
+  `${JSON.stringify(
+    {
+      archive: basename(archivePath),
+      command: commandName,
+      displayName: 'Beeper CLI',
+      package: packageName,
+      path: archivePath,
+      sha256,
+      version,
+    },
+    null,
+    2,
+  )}\n`,
+);
+
+console.log(`${archivePath}`);
+console.log(`sha256 ${sha256}`);
+await rm(workDir, {recursive: true, force: true});
+
+async function ensureBuilt() {
+  if (!existsSync(distPath)) {
+    throw new Error('dist/ does not exist. Run npm run build before packaging.');
+  }
+
+  const distStats = await stat(distPath);
+  if (!distStats.isDirectory()) {
+    throw new Error('dist/ exists but is not a directory.');
+  }
+
+  if (!existsSync(join(distPath, 'commands'))) {
+    throw new Error('dist/commands does not exist. Run npm run build before packaging.');
+  }
+}
+
+async function hashFile(path) {
+  const hash = createHash('sha256');
+  hash.update(await readFile(path));
+  return hash.digest('hex');
+}
+
+async function run(command, args, options = {}) {
+  await new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd || root,
+      env: process.env,
+      stdio: 'inherit',
+    });
+
+    child.on('error', reject);
+    child.on('exit', code => {
+      if (code === 0) {
+        resolvePromise();
+        return;
+      }
+
+      reject(new Error(`${command} ${args.join(' ')} exited with ${code}`));
+    });
+  });
+}
diff --git a/scripts/check-api-copy.mjs b/scripts/check-api-copy.mjs
new file mode 100644
index 0000000..40bcaee
--- /dev/null
+++ b/scripts/check-api-copy.mjs
@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import {readFile} from 'node:fs/promises';
+import {join, resolve} from 'node:path';
+
+const root = resolve(new URL('..', import.meta.url).pathname);
+const {apiCopy} = await import('../dist/lib/copy.js');
+
+const checks = [
+  ['accounts.list', 'resources/accounts/accounts.d.ts', 'list'],
+  ['assets.download', 'resources/assets.d.ts', 'download'],
+  ['assets.upload', 'resources/assets.d.ts', 'upload'],
+  ['chats.archive', 'resources/chats/chats.d.ts', 'archive'],
+  ['chats.create', 'resources/chats/chats.d.ts', 'create'],
+  ['chats.list', 'resources/chats/chats.d.ts', 'list'],
+  ['chats.markRead', 'resources/chats/chats.d.ts', 'markRead'],
+  ['chats.markUnread', 'resources/chats/chats.d.ts', 'markUnread'],
+  ['chats.notifyAnyway', 'resources/chats/chats.d.ts', 'notifyAnyway'],
+  ['chats.retrieve', 'resources/chats/chats.d.ts', 'retrieve'],
+  ['chats.search', 'resources/chats/chats.d.ts', 'search'],
+  ['chats.start', 'resources/chats/chats.d.ts', 'start'],
+  ['contacts.search', 'resources/accounts/contacts.d.ts', 'search'],
+  ['messages.delete', 'resources/messages.d.ts', 'delete'],
+  ['messages.list', 'resources/messages.d.ts', 'list'],
+  ['messages.retrieve', 'resources/messages.d.ts', 'retrieve'],
+  ['messages.search', 'resources/messages.d.ts', 'search'],
+  ['messages.send', 'resources/messages.d.ts', 'send'],
+  ['messages.update', 'resources/messages.d.ts', 'update'],
+  ['reactions.add', 'resources/chats/messages/reactions.d.ts', 'add'],
+  ['reactions.delete', 'resources/chats/messages/reactions.d.ts', 'delete'],
+  ['reminders.create', 'resources/chats/reminders.d.ts', 'create'],
+  ['reminders.delete', 'resources/chats/reminders.d.ts', 'delete'],
+];
+
+const failures = [];
+
+for (const [copyPath, sdkPath, method] of checks) {
+  const expected = getPath(apiCopy, copyPath);
+  const actual = await sdkMethodDescription(sdkPath, method);
+  if (expected !== actual) {
+    failures.push(`${copyPath}\n  expected: ${expected}\n  actual:   ${actual}`);
+  }
+}
+
+if (failures.length > 0) {
+  console.error(`API copy drifted from @beeper/desktop-api:\n\n${failures.join('\n\n')}`);
+  process.exit(1);
+}
+
+console.log(`api-copy: ${checks.length} SDK descriptions verified`);
+
+function getPath(object, path) {
+  return path.split('.').reduce((value, key) => value?.[key], object);
+}
+
+async function sdkMethodDescription(relativePath, method) {
+  const source = await readFile(join(root, 'node_modules', '@beeper', 'desktop-api', relativePath), 'utf8');
+  const methodMatch = source.match(new RegExp(String.raw`^\s*${method}\(`, 'm'));
+  const methodIndex = methodMatch?.index ?? -1;
+  if (methodIndex === -1) throw new Error(`Could not find SDK method ${relativePath}#${method}`);
+
+  const comments = [...source.slice(0, methodIndex).matchAll(/\/\*\*([\s\S]*?)\*\//g)];
+  const match = comments.at(-1);
+  if (!match) throw new Error(`Could not find SDK docs for ${relativePath}#${method}`);
+
+  const lines = match[1]
+    .split('\n')
+    .map(line => line.replace(/^\s*\*\s?/, '').trimEnd())
+
+  const exampleIndex = lines.findIndex(line => line.startsWith('@example'));
+  return lines
+    .slice(0, exampleIndex === -1 ? undefined : exampleIndex)
+    .filter(Boolean)
+    .join(' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
diff --git a/scripts/generate-readme.mjs b/scripts/generate-readme.mjs
new file mode 100644
index 0000000..0b69bc8
--- /dev/null
+++ b/scripts/generate-readme.mjs
@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+import {readFile, writeFile} from 'node:fs/promises';
+import {Config} from '@oclif/core/config';
+
+const config = await Config.load({root: process.cwd()});
+const check = process.argv.includes('--check');
+const commands = [...config.commands]
+  .filter(command => !command.hidden)
+  .sort((a, b) => displayID(a.id).localeCompare(displayID(b.id)));
+
+const globalFlags = new Set(['base-url', 'debug', 'json']);
+const commandList = commands.map(command => {
+  const id = displayID(command.id);
+  return `| \`${id}\` | ${escapeTable(text(command.summary || command.description || ''))} |`;
+});
+
+const commandSections = commands.map(command => commandSection(command)).join('\n\n');
+
+const readme = `# Beeper CLI
+
+Command-line access to the [Beeper Desktop API](https://developers.beeper.com/desktop-api/).
+
+The CLI is built with TypeScript, oclif, and the official \`@beeper/desktop-api\`
+SDK. The command reference below is generated from the oclif command metadata in
+the built CLI.
+
+## Install
+
+Beeper CLI is distributed through Homebrew as a built release archive:
+
+\`\`\`sh
+brew install beeper/tap/beeper-cli
+\`\`\`
+
+The installed command is \`beeper\`.
+
+## Local Development
+
+\`\`\`sh
+npm install
+npm run build
+node ./bin/run.js --help
+\`\`\`
+
+Run commands directly from TypeScript:
+
+\`\`\`sh
+npm run dev -- --help
+\`\`\`
+
+Regenerate this README after command, flag, or argument changes:
+
+\`\`\`sh
+npm run readme
+\`\`\`
+
+## Authenticate
+
+\`\`\`sh
+beeper chats
+beeper auth status
+\`\`\`
+
+On first use, authenticated commands look for a local Beeper Desktop API on the
+default port range. If Beeper Desktop is already signed in, the CLI immediately
+uses OAuth2 Authorization Code with PKCE and stores the server URL and bearer
+token in \`~/.config/beeper/config.json\`. After that, commands reuse the
+remembered server URL.
+
+If the local Desktop app is not authenticated, the CLI exits with an error
+instead of starting another login flow. You can explicitly sign in the app
+itself with:
+
+\`\`\`sh
+beeper login --app-login --email you@example.com
+\`\`\`
+
+For non-interactive use, pass a token through the environment:
+
+\`\`\`sh
+BEEPER_ACCESS_TOKEN=... beeper chats --json
+\`\`\`
+
+## Common Workflows
+
+\`\`\`sh
+beeper doctor
+beeper status
+beeper accounts
+beeper chats
+beeper messages "Family"
+beeper send "Family" "on my way" --wait
+beeper export --out ./beeper-export
+beeper api get /v1/info
+\`\`\`
+
+## Input Resolution
+
+- Chat arguments accept Beeper chat IDs, local chat IDs, exact titles, or search text.
+- Ambiguous chat matches return numbered choices; pass \`--pick N\` to select one.
+- Account arguments accept account IDs, network names, bridge type/id, or account user identity.
+- Account filters can expand a network name to multiple matching accounts.
+- \`contacts search\` and \`start-chat\` can search across all accounts when \`--account\` is omitted.
+- \`contacts list\` accepts the same account selectors as other account-scoped commands.
+
+## Output
+
+Most commands support:
+
+- app-like text by default, optimized for scanning chats, messages, contacts, accounts, and assets
+- \`--json\` for exact API-shaped structured output
+- \`--debug\` for SDK debug logging
+- \`--base-url\` to point at a different local Desktop API server
+
+Use \`beeper login --server-url URL\` to remember a Desktop API server URL for
+future commands.
+
+\`commands --json\` prints a compact command manifest for tools and agents.
+\`llm\` prints a concise human-readable command guide.
+
+## Environment
+
+| Environment variable | Description |
+| --- | --- |
+| \`BEEPER_ACCESS_TOKEN\` | Bearer token. Overrides stored OAuth login. |
+| \`BEEPER_DESKTOP_BASE_URL\` | Beeper Desktop API base URL. Defaults to \`http://localhost:23373\`. |
+| \`BEEPER_BASE_URL\` | SDK-compatible base URL fallback. |
+| \`BEEPER_CLI_CONFIG_DIR\` | Override config directory for testing or isolated profiles. |
+
+## Command Summary
+
+| Command | Summary |
+| --- | --- |
+${commandList.join('\n')}
+
+## Command Reference
+
+${commandSections}
+
+## Publishing
+
+Beeper CLI releases are built as Homebrew archives and uploaded to GitHub
+Releases. Push a \`v*\` tag to run \`.github/workflows/publish-release.yml\`.
+
+The release workflow:
+
+- runs the TypeScript test suite
+- builds a Homebrew archive containing the compiled CLI and production dependencies
+- uploads the archive to the GitHub release
+- updates \`beeper/homebrew-tap\` with the pinned archive SHA
+
+Required repository secrets:
+
+- \`HOMEBREW_TAP_GITHUB_TOKEN\`
+`;
+
+if (check) {
+  const current = await readFile('README.md', 'utf8');
+  if (current !== readme) {
+    console.error('README.md is out of date. Run npm run readme.');
+    process.exit(1);
+  }
+} else {
+  await writeFile('README.md', readme);
+}
+
+function commandSection(command) {
+  const id = displayID(command.id);
+  const usage = usageFor(command);
+  const parts = [
+    `### \`beeper ${id}\``,
+    text(command.summary || command.description || ''),
+    '',
+    '```sh',
+    usage,
+    '```',
+  ];
+
+  const args = Object.values(command.args || {});
+  if (args.length > 0) {
+    parts.push('', 'Arguments:', '', '| Name | Required | Description |', '| --- | --- | --- |');
+    for (const arg of args) {
+      parts.push(`| \`${arg.name}\` | ${arg.required ? 'yes' : 'no'} | ${escapeTable(arg.description || '')} |`);
+    }
+  }
+
+  const flags = Object.values(command.flags || {}).filter(flag => !globalFlags.has(flag.name));
+  if (flags.length > 0) {
+    parts.push('', 'Flags:', '', '| Flag | Type | Description |', '| --- | --- | --- |');
+    for (const flag of flags.sort((a, b) => a.name.localeCompare(b.name))) {
+      parts.push(`| \`${flagLabel(flag)}\` | ${flag.type || 'boolean'} | ${escapeTable(flagDescription(flag))} |`);
+    }
+  }
+
+  const inherited = Object.values(command.flags || {}).filter(flag => globalFlags.has(flag.name));
+  if (inherited.length > 0) {
+    parts.push('', `Global flags: ${inherited.map(flag => `\`--${flag.name}\``).join(', ')}.`);
+  }
+
+  return parts.filter((part, index, array) => part !== '' || array[index - 1] !== '').join('\n');
+}
+
+function displayID(id) {
+  return id.replaceAll(':', ' ');
+}
+
+function usageFor(command) {
+  const args = Object.values(command.args || {}).map(arg => arg.required ? `<${arg.name}>` : `[${arg.name}]`);
+  return ['beeper', displayID(command.id), ...args].join(' ');
+}
+
+function flagLabel(flag) {
+  const prefix = flag.char ? `-${flag.char}, --${flag.name}` : `--${flag.name}`;
+  if (flag.type === 'boolean') return prefix;
+  const value = flag.options?.length ? `<${flag.options.join('|')}>` : '<value>';
+  return `${prefix}=${value}${flag.multiple ? '...' : ''}`;
+}
+
+function flagDescription(flag) {
+  const details = [];
+  if (flag.description) details.push(text(flag.description));
+  if (flag.default !== undefined) details.push(`Default: ${String(flag.default)}`);
+  if (flag.required) details.push('Required.');
+  return details.join(' ');
+}
+
+function escapeTable(value) {
+  return text(value).replaceAll('|', '\\|').replace(/\s+/g, ' ').trim();
+}
+
+function text(value) {
+  return String(value)
+    .replaceAll('<%= config.bin %>', config.bin)
+    .replaceAll('<%= command.id %>', '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
diff --git a/scripts/link b/scripts/link
index 2da9715..b8e388f 100755
--- a/scripts/link
+++ b/scripts/link
@@ -4,10 +4,5 @@ set -euo pipefail
 
 cd "$(dirname "$0")/.."
 
-# Mark the necessary Go modules as private to avoid Go's proxy
-export GOPRIVATE="${GOPRIVATE:+$GOPRIVATE,}github.com/beeper/desktop-api-go,github.com/stainless-sdks/beeper-desktop-api-go"
-
-REPLACEMENT="${1:-"../beeperdesktop-go"}"
-echo "==> Replacing Go SDK with $REPLACEMENT"
-go mod edit -replace github.com/beeper/desktop-api-go="$REPLACEMENT"
-go mod tidy -e
+echo "==> Linking Beeper CLI"
+npm link
diff --git a/scripts/lint b/scripts/lint
index bfcb7b6..91d312a 100755
--- a/scripts/lint
+++ b/scripts/lint
@@ -4,8 +4,5 @@ set -euo pipefail
 
 cd "$(dirname "$0")/.."
 
-# Mark the necessary Go modules as private to avoid Go's proxy
-export GOPRIVATE="${GOPRIVATE:+$GOPRIVATE,}github.com/beeper/desktop-api-go,github.com/stainless-sdks/beeper-desktop-api-go"
-
-echo "==> Running Go build"
-go build ./...
+echo "==> Typechecking Beeper CLI"
+npm run typecheck
diff --git a/scripts/publish-homebrew-formula.mjs b/scripts/publish-homebrew-formula.mjs
new file mode 100644
index 0000000..f621fd8
--- /dev/null
+++ b/scripts/publish-homebrew-formula.mjs
@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import {existsSync} from 'node:fs';
+import {mkdir, mkdtemp, readFile, rm, writeFile} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {spawn} from 'node:child_process';
+
+const root = new URL('..', import.meta.url).pathname;
+const packageJson = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
+const metadata = JSON.parse(await readFile(new URL('../dist/release/homebrew.json', import.meta.url), 'utf8'));
+
+const token = process.env.HOMEBREW_TAP_GITHUB_TOKEN;
+const tapRepository = process.env.HOMEBREW_TAP_REPOSITORY || 'beeper/homebrew-tap';
+const sourceRepository = process.env.GITHUB_REPOSITORY || 'beeper/desktop-api-cli';
+const version = process.env.PACKAGE_VERSION || metadata.version || packageJson.version;
+const formulaName = process.env.HOMEBREW_FORMULA_NAME || 'beeper-cli';
+const commandName = process.env.HOMEBREW_COMMAND_NAME || metadata.command || 'beeper';
+const formulaClass = formulaName
+  .split(/[-_]/)
+  .map(part => `${part[0].toUpperCase()}${part.slice(1)}`)
+  .join('');
+const tag = process.env.GITHUB_REF_NAME || `v${version}`;
+
+if (!token) {
+  throw new Error('HOMEBREW_TAP_GITHUB_TOKEN is required to publish the Homebrew formula.');
+}
+
+const cloneRoot = await mkdtemp(join(tmpdir(), 'beeper-cli-homebrew-'));
+const tapPath = join(cloneRoot, 'tap');
+const remote = `https://x-access-token:${token}@github.com/${tapRepository}.git`;
+
+try {
+  await run('git', ['clone', '--depth', '1', remote, tapPath], {cwd: cloneRoot, scrub: token});
+  await run('git', ['config', 'user.name', process.env.GIT_AUTHOR_NAME || 'beeper-release-bot'], {cwd: tapPath});
+  await run('git', ['config', 'user.email', process.env.GIT_AUTHOR_EMAIL || 'help@beeper.com'], {cwd: tapPath});
+
+  const formulaDir = join(tapPath, 'Formula');
+  const formulaPath = join(formulaDir, `${formulaName}.rb`);
+  if (!existsSync(formulaDir)) {
+    await mkdir(formulaDir, {recursive: true});
+  }
+
+  await writeFile(
+    formulaPath,
+    formula({formulaClass, formulaName, sourceRepository, tag, version, metadata, commandName}),
+  );
+  await run('git', ['add', formulaPath], {cwd: tapPath});
+
+  const changed = await output('git', ['diff', '--cached', '--quiet'], {cwd: tapPath, allowFailure: true});
+  if (changed.code === 0) {
+    console.log('Homebrew formula is already current.');
+  } else {
+    await run('git', ['commit', '-m', `${formulaName} ${version}`], {cwd: tapPath});
+    await run('git', ['push', 'origin', 'HEAD'], {cwd: tapPath, scrub: token});
+  }
+} finally {
+  await rm(cloneRoot, {recursive: true, force: true});
+}
+
+function formula({formulaClass, formulaName, sourceRepository, tag, version, metadata, commandName}) {
+  return `class ${formulaClass} < Formula
+  desc "Beeper CLI"
+  homepage "https://developers.beeper.com/desktop-api/"
+  url "https://github.com/${sourceRepository}/releases/download/${tag}/${metadata.archive}"
+  sha256 "${metadata.sha256}"
+  license "MIT"
+  version "${version}"
+
+  depends_on "node"
+
+  def install
+    libexec.install Dir["libexec/*"]
+    bin.install "bin/${commandName}"
+    bin.install_symlink bin/"${commandName}" => "${formulaName}"
+  end
+
+  test do
+    assert_match version.to_s, shell_output("#{bin}/${commandName} --version")
+  end
+end
+`;
+}
+
+async function run(command, args, options = {}) {
+  const result = await output(command, args, options);
+  if (result.code !== 0) {
+    throw new Error(`${command} ${args.join(' ')} exited with ${result.code}`);
+  }
+}
+
+async function output(command, args, options = {}) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd || root,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => {
+      const text = chunk.toString();
+      stdout += text;
+      process.stdout.write(options.scrub ? text.replaceAll(options.scrub, '[token]') : text);
+    });
+    child.stderr.on('data', chunk => {
+      const text = chunk.toString();
+      stderr += text;
+      process.stderr.write(options.scrub ? text.replaceAll(options.scrub, '[token]') : text);
+    });
+    child.on('error', reject);
+    child.on('exit', code => {
+      if (code !== 0 && !options.allowFailure) {
+        resolvePromise({code, stdout, stderr});
+        return;
+      }
+
+      resolvePromise({code, stdout, stderr});
+    });
+  });
+}
diff --git a/scripts/run b/scripts/run
index 5cfec5f..e3954af 100755
--- a/scripts/run
+++ b/scripts/run
@@ -4,7 +4,4 @@ set -euo pipefail
 
 cd "$(dirname "$0")/.."
 
-# Mark the necessary Go modules as private to avoid Go's proxy
-export GOPRIVATE="${GOPRIVATE:+$GOPRIVATE,}github.com/beeper/desktop-api-go,github.com/stainless-sdks/beeper-desktop-api-go"
-
-go run ./cmd/beeper-desktop-cli "$@"
+npm run dev -- "$@"
diff --git a/scripts/test b/scripts/test
index 9f448ce..9f5362b 100755
--- a/scripts/test
+++ b/scripts/test
@@ -4,9 +4,6 @@ set -euo pipefail
 
 cd "$(dirname "$0")/.."
 
-# Mark the necessary Go modules as private to avoid Go's proxy
-export GOPRIVATE="${GOPRIVATE:+$GOPRIVATE,}github.com/beeper/desktop-api-go,github.com/stainless-sdks/beeper-desktop-api-go"
-
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[0;33m'
@@ -56,9 +53,4 @@ else
 fi
 
 echo "==> Running tests"
-go test ./... "$@"
-
-echo "==> Checking tests on Windows"
-GOARCH=amd64 GOOS=windows go test -c ./... "$@"
-# `go test -c` produces a bunch of .exe files; make sure to clean those up
-find . -name "*.test.exe" -exec rm {} \;
+npm test -- "$@"
diff --git a/scripts/unlink b/scripts/unlink
index dfb62ae..b9a8f83 100755
--- a/scripts/unlink
+++ b/scripts/unlink
@@ -4,5 +4,5 @@ set -e
 
 cd "$(dirname "$0")/.."
 
-echo "==> Unlinking with local directory"
-go mod edit -dropreplace github.com/beeper/desktop-api-go
+echo "==> Unlinking Beeper CLI"
+npm unlink -g beeper-cli || true
diff --git a/scripts/utils/upload-artifact.sh b/scripts/utils/upload-artifact.sh
deleted file mode 100755
index 9848696..0000000
--- a/scripts/utils/upload-artifact.sh
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/usr/bin/env bash
-set -exuo pipefail
-
-BINARY_NAME="beeper-desktop-cli"
-DIST_DIR="dist"
-FILENAME="dist.zip"
-
-files=()
-while IFS= read -r -d '' file; do
-  files+=("$file")
-done < <(find "$DIST_DIR" -type f \( \
-  -path "*amd64*/$BINARY_NAME" -o \
-  -path "*arm64*/$BINARY_NAME" -o \
-  -path "*amd64*/${BINARY_NAME}.exe" -o \
-  -path "*arm64*/${BINARY_NAME}.exe" \
-  \) -print0)
-
-if [[ ${#files[@]} -eq 0 ]]; then
-  echo -e "\033[31mNo binaries found for packaging.\033[0m"
-  exit 1
-fi
-
-rm -f "${DIST_DIR}/${FILENAME}"
-
-while IFS= read -r -d '' dir; do
-  printf "Remove the quarantine attribute before running the executable:\n\nxattr -d com.apple.quarantine %s\n" \
-    "$BINARY_NAME" >"${dir}/README.txt"
-  files+=("${dir}/README.txt")
-done < <(find "$DIST_DIR" -type d -path '*macos*' -print0)
-
-relative_files=()
-for file in "${files[@]}"; do
-  relative_files+=("${file#"${DIST_DIR}"/}")
-done
-
-(cd "$DIST_DIR" && zip -r "$FILENAME" "${relative_files[@]}")
-
-RESPONSE=$(curl -X POST "$URL?filename=$FILENAME" \
-  -H "Authorization: Bearer $AUTH" \
-  -H "Content-Type: application/json")
-
-SIGNED_URL=$(echo "$RESPONSE" | jq -r '.url')
-
-if [[ "$SIGNED_URL" == "null" ]]; then
-  echo -e "\033[31mFailed to get signed URL.\033[0m"
-  exit 1
-fi
-
-UPLOAD_RESPONSE=$(curl -v -X PUT \
-  -H "Content-Type: application/zip" \
-  --data-binary "@${DIST_DIR}/${FILENAME}" "$SIGNED_URL" 2>&1)
-
-if echo "$UPLOAD_RESPONSE" | grep -q "HTTP/[0-9.]* 200"; then
-  echo -e "\033[32mUploaded build to Stainless storage.\033[0m"
-  echo -e "\033[32mInstallation: Download and unzip: 'https://pkg.stainless.com/s/beeper-desktop-api-cli/$SHA'. On macOS, run 'xattr -d com.apple.quarantine {executable name}'.\033[0m"
-else
-  echo -e "\033[31mFailed to upload artifact.\033[0m"
-  exit 1
-fi
diff --git a/skills-lock.json b/skills-lock.json
new file mode 100644
index 0000000..81df08c
--- /dev/null
+++ b/skills-lock.json
@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "skills": {
+    "opentui": {
+      "source": "anomalyco/opentui",
+      "sourceType": "github",
+      "skillPath": "packages/web/src/content/SKILL.md",
+      "computedHash": "9371d09c264df7e00c19ab2fcafb98121be3652c7a4f3d738c6d6fea3265f57b"
+    }
+  }
+}
diff --git a/src/commands/accounts.ts b/src/commands/accounts.ts
new file mode 100644
index 0000000..f2812d5
--- /dev/null
+++ b/src/commands/accounts.ts
@@ -0,0 +1,47 @@
+import { Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy } from '../lib/copy.js'
+import { printData, printList } from '../lib/output.js'
+import { withSpinner } from '../lib/ui.js'
+
+function accountItems(accounts: unknown): unknown[] {
+  if (Array.isArray(accounts)) return accounts
+  return (accounts as { items?: unknown[] }).items ?? []
+}
+
+export default class Accounts extends Command {
+  static override summary = apiCopy.accounts.list
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(Accounts)
+    const client = await createClient(flags)
+    const useSpinner = !flags.json
+    const accounts = useSpinner
+      ? await withSpinner('Loading accounts…', () => client.accounts.list(), {
+        done: value => {
+          const count = accountItems(value).length
+          return `${count} account${count === 1 ? '' : 's'}`
+        },
+      })
+      : await client.accounts.list()
+    if (flags.json) {
+      await printData(accounts, 'json')
+      return
+    }
+    const items = accountItems(accounts)
+    await printList(items, 'human', {
+      title: 'No accounts connected',
+      subtitle: 'Add an account to start chatting from the CLI.',
+      suggestions: [
+        { command: 'beeper accounts add', hint: 'browse and connect a network' },
+        { command: 'beeper accounts add WhatsApp', hint: 'connect a specific network' },
+        { command: 'beeper auth login', hint: 'sign in to Beeper Desktop first' },
+      ],
+    })
+  }
+}
diff --git a/src/commands/accounts/add.ts b/src/commands/accounts/add.ts
new file mode 100644
index 0000000..18b612f
--- /dev/null
+++ b/src/commands/accounts/add.ts
@@ -0,0 +1,166 @@
+import { createInterface } from 'node:readline/promises'
+import { stdin as input, stdout as output } from 'node:process'
+import { Args, Command, Flags } from '@oclif/core'
+import type { BridgeAvailability } from '@beeper/desktop-api/resources/bridges.js'
+import type { AuthListFlowsResponse } from '@beeper/desktop-api/resources/matrix/bridges/auth.js'
+import { createClient } from '../../lib/client.js'
+import { printAccountLoginStep, runGuidedAccountLogin } from '../../lib/account-login.js'
+import { printData } from '../../lib/output.js'
+
+type AccountType = BridgeAvailability
+
+export default class AccountsAdd extends Command {
+  static override summary = 'Add a Beeper account'
+  static override args = {
+    account: Args.string({ description: 'Account type to add, for example WhatsApp, Discord, or local-whatsapp' }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    cookie: Flags.string({ description: 'Cookie value for non-interactive login, in name=value form. Repeat for multiple cookies.', multiple: true }),
+    debug: Flags.boolean({ default: false }),
+    field: Flags.string({ description: 'Field value for non-interactive login, in id=value form. Repeat for multiple fields.', multiple: true }),
+    flow: Flags.string({ description: 'Login flow ID. If omitted, Desktop chooses the default flow.' }),
+    guided: Flags.boolean({ default: true, allowNo: true, description: 'Prompt through login steps until completion' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+    'login-id': Flags.string({ description: 'Existing login ID to re-login as' }),
+    'non-interactive': Flags.boolean({ default: false, description: 'Do not prompt; require --flow, --field, and --cookie values when needed.' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(AccountsAdd)
+    const client = await createClient(flags)
+
+    if (!args.account) {
+      const bridges = await client.bridges.list()
+      if (flags.json) {
+        await printData(bridges, 'json')
+        return
+      }
+
+      printAvailableAccounts(bridges.items)
+      return
+    }
+
+    const bridges = await client.bridges.list()
+    const accountType = resolveAccountType(bridges.items, args.account)
+    if (accountType.status !== 'available') {
+      const suffix = accountType.statusText ? `: ${accountType.statusText}` : ''
+      throw new Error(`${accountType.displayName} is not available${suffix}`)
+    }
+
+    let flowID = flags.flow
+    if (!flowID) {
+      const flows = await client.matrix.bridges.auth.listFlows(accountType.bridgeID)
+      const loginFlows = flows.flows ?? []
+      if (loginFlows.length > 1 && flags['non-interactive']) throw new Error(`Multiple sign-in methods are available for ${accountType.displayName}. Pass --flow.`)
+      flowID = loginFlows.length > 1 && flags.guided && !flags.json
+        ? await chooseLoginFlow(loginFlows)
+        : loginFlows[0]?.id
+      if (!flowID) throw new Error(`No login flows returned for ${accountType.displayName}.`)
+      if (!flags.json && loginFlows.length > 1) this.log(`Using flow ${flowID}`)
+    }
+
+    const step = await client.matrix.bridges.auth.startLogin(flowID, {
+      bridgeID: accountType.bridgeID,
+      login_id: flags['login-id'],
+    })
+    const result = flags.guided ? await runGuidedAccountLogin(client, accountType.bridgeID, step, {
+      cookies: parseKeyValueFlags(flags.cookie, '--cookie'),
+      fields: parseKeyValueFlags(flags.field, '--field'),
+      nonInteractive: flags['non-interactive'],
+    }) : step
+    if (flags.json) await printData(result, 'json')
+    else if (!flags.guided) printAccountLoginStep(result)
+    else if ('complete' in result) this.log('Account was connected successfully!')
+  }
+}
+
+function printAvailableAccounts(items: AccountType[]): void {
+  const sections: Array<[string, AccountType[]]> = [
+    ['On-Device Accounts', items.filter(item => item.bridgeProvider === 'local')],
+    ['Beeper Cloud Accounts', items.filter(item => item.bridgeProvider === 'cloud')],
+    ['Self-Hosted Accounts', items.filter(item => item.bridgeProvider === 'self-hosted')],
+  ]
+
+  for (const [title, accounts] of sections) {
+    if (!accounts.length) continue
+    process.stdout.write(`${title}\n`)
+    for (const account of accounts) {
+      const status = account.statusText ?? statusLabel(account)
+      process.stdout.write(`  ${account.displayName} (${account.bridgeID})${status ? ` - ${status}` : ''}\n`)
+    }
+    process.stdout.write('\n')
+  }
+}
+
+function resolveAccountType(items: AccountType[], input: string): AccountType {
+  const normalizedInput = normalize(input)
+  const exact = items.filter(item => [
+    item.bridgeID,
+    item.displayName,
+    item.network,
+    item.bridgeType,
+  ].some(value => normalize(value) === normalizedInput))
+
+  if (exact.length === 1) return exact[0]!
+  if (exact.length > 1) throw ambiguousAccountType(input, exact)
+
+  const partial = items.filter(item => [
+    item.bridgeID,
+    item.displayName,
+    item.network,
+    item.bridgeType,
+  ].some(value => normalize(value).includes(normalizedInput)))
+
+  if (partial.length === 1) return partial[0]!
+  if (partial.length > 1) throw ambiguousAccountType(input, partial)
+  throw new Error(`Unknown account type ${input}. Run \`beeper accounts add\` to list available account types.`)
+}
+
+function ambiguousAccountType(input: string, matches: AccountType[]): Error {
+  const options = matches.map(item => `${item.displayName} (${item.bridgeID})`).join(', ')
+  return new Error(`Account type ${input} is ambiguous. Use one of: ${options}`)
+}
+
+function statusLabel(account: AccountType): string | undefined {
+  if (account.status === 'available') return undefined
+  if (account.status === 'connected') return `${account.displayName} Connected`
+  return account.status.replaceAll('_', ' ')
+}
+
+function normalize(value: string | undefined): string {
+  return (value ?? '').toLowerCase().replaceAll(/[^a-z0-9]+/g, '')
+}
+
+function parseKeyValueFlags(values: string[] | undefined, flagName: string): Record<string, string> {
+  const parsed: Record<string, string> = {}
+  for (const value of values ?? []) {
+    const equalsIndex = value.indexOf('=')
+    if (equalsIndex <= 0) throw new Error(`${flagName} must use name=value form.`)
+    parsed[value.slice(0, equalsIndex)] = value.slice(equalsIndex + 1)
+  }
+
+  return parsed
+}
+
+async function chooseLoginFlow(flows: NonNullable<AuthListFlowsResponse['flows']>): Promise<string> {
+  process.stdout.write('Choose how you want to sign in:\n')
+  flows.forEach((flow, index) => {
+    const description = flow.description ? ` - ${flow.description}` : ''
+    process.stdout.write(`  ${index + 1}. ${flow.name}${description}\n`)
+  })
+
+  const rl = createInterface({ input, output })
+  try {
+    for (;;) {
+      const answer = (await rl.question('Select a sign-in method: ')).trim()
+      const selected = Number.parseInt(answer, 10)
+      if (Number.isInteger(selected) && selected >= 1 && selected <= flows.length) return flows[selected - 1]!.id
+      const byID = flows.find(flow => flow.id === answer)
+      if (byID) return byID.id
+      process.stdout.write('Choose one of the listed sign-in methods.\n')
+    }
+  } finally {
+    rl.close()
+  }
+}
diff --git a/src/commands/api/get.ts b/src/commands/api/get.ts
new file mode 100644
index 0000000..e26698e
--- /dev/null
+++ b/src/commands/api/get.ts
@@ -0,0 +1,21 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../../lib/client.js'
+import { printData } from '../../lib/output.js'
+
+export default class ApiGet extends Command {
+  static override summary = 'Call a raw Desktop API GET path'
+  static override args = {
+    path: Args.string({ description: 'API path, for example /v1/info', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: true, allowNo: true, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(ApiGet)
+    const client = await createClient(flags)
+    await printData(await client.get(args.path), flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/api/post.ts b/src/commands/api/post.ts
new file mode 100644
index 0000000..3ea4914
--- /dev/null
+++ b/src/commands/api/post.ts
@@ -0,0 +1,23 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../../lib/client.js'
+import { printData } from '../../lib/output.js'
+
+export default class ApiPost extends Command {
+  static override summary = 'Call a raw Desktop API POST path with a JSON body'
+  static override args = {
+    path: Args.string({ description: 'API path, for example /v1/messages/{chatID}/send', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    body: Flags.string({ default: '{}', description: 'JSON request body' }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: true, allowNo: true, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(ApiPost)
+    const client = await createClient(flags)
+    const body = JSON.parse(flags.body) as Record<string, unknown>
+    await printData(await client.post(args.path, { body }), flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/e2ee/recovery-code/mark-backed-up.ts b/src/commands/app/e2ee/recovery-code/mark-backed-up.ts
new file mode 100644
index 0000000..2e22a04
--- /dev/null
+++ b/src/commands/app/e2ee/recovery-code/mark-backed-up.ts
@@ -0,0 +1,20 @@
+import { Command, Flags } from '@oclif/core'
+import type { RecoveryCodeMarkBackedUpResponse } from '@beeper/desktop-api/resources/app/e2ee/recovery-code/recovery-code.js'
+import { appRequest } from '../../../../lib/app-api.js'
+import { printData } from '../../../../lib/output.js'
+
+export default class AppE2EERecoveryCodeMarkBackedUp extends Command {
+  static override summary = 'Mark the recovery key as saved'
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(AppE2EERecoveryCodeMarkBackedUp)
+    const result = await appRequest<RecoveryCodeMarkBackedUpResponse>('POST', '/v1/app/e2ee/recovery-code/mark-backed-up', {
+      baseURL: flags['base-url'],
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/e2ee/recovery-code/reset/begin.ts b/src/commands/app/e2ee/recovery-code/reset/begin.ts
new file mode 100644
index 0000000..4a81da8
--- /dev/null
+++ b/src/commands/app/e2ee/recovery-code/reset/begin.ts
@@ -0,0 +1,22 @@
+import { Command, Flags } from '@oclif/core'
+import type { ResetBeginResponse } from '@beeper/desktop-api/resources/app/e2ee/recovery-code/reset.js'
+import { appRequest } from '../../../../../lib/app-api.js'
+import { printData } from '../../../../../lib/output.js'
+
+export default class AppE2EERecoveryCodeResetBegin extends Command {
+  static override summary = 'Create a new recovery key'
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    'recovery-code': Flags.string({ description: 'Existing recovery key, if available' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(AppE2EERecoveryCodeResetBegin)
+    const result = await appRequest<ResetBeginResponse>('POST', '/v1/app/e2ee/recovery-code/reset', {
+      baseURL: flags['base-url'],
+      body: flags['recovery-code'] ? { recoveryCode: flags['recovery-code'] } : {},
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/e2ee/recovery-code/reset/confirm.ts b/src/commands/app/e2ee/recovery-code/reset/confirm.ts
new file mode 100644
index 0000000..fed6c58
--- /dev/null
+++ b/src/commands/app/e2ee/recovery-code/reset/confirm.ts
@@ -0,0 +1,24 @@
+import { Args, Command, Flags } from '@oclif/core'
+import type { ResetConfirmResponse } from '@beeper/desktop-api/resources/app/e2ee/recovery-code/reset.js'
+import { appRequest } from '../../../../../lib/app-api.js'
+import { printData } from '../../../../../lib/output.js'
+
+export default class AppE2EERecoveryCodeResetConfirm extends Command {
+  static override summary = 'Confirm a newly created recovery key'
+  static override args = {
+    recoveryCode: Args.string({ description: 'New recovery key returned by reset begin', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(AppE2EERecoveryCodeResetConfirm)
+    const result = await appRequest<ResetConfirmResponse>('POST', '/v1/app/e2ee/recovery-code/reset/confirm', {
+      baseURL: flags['base-url'],
+      body: { recoveryCode: args.recoveryCode },
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/e2ee/recovery-code/verify.ts b/src/commands/app/e2ee/recovery-code/verify.ts
new file mode 100644
index 0000000..494a8b2
--- /dev/null
+++ b/src/commands/app/e2ee/recovery-code/verify.ts
@@ -0,0 +1,24 @@
+import { Args, Command, Flags } from '@oclif/core'
+import type { RecoveryCodeVerifyResponse } from '@beeper/desktop-api/resources/app/e2ee/recovery-code/recovery-code.js'
+import { appRequest } from '../../../../lib/app-api.js'
+import { printData } from '../../../../lib/output.js'
+
+export default class AppE2EERecoveryCodeVerify extends Command {
+  static override summary = 'Unlock encrypted messages with a recovery key'
+  static override args = {
+    recoveryCode: Args.string({ description: 'Beeper recovery key', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(AppE2EERecoveryCodeVerify)
+    const result = await appRequest<RecoveryCodeVerifyResponse>('POST', '/v1/app/e2ee/recovery-code/verify', {
+      baseURL: flags['base-url'],
+      body: { recoveryCode: args.recoveryCode },
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/e2ee/verification/accept.ts b/src/commands/app/e2ee/verification/accept.ts
new file mode 100644
index 0000000..34dc44b
--- /dev/null
+++ b/src/commands/app/e2ee/verification/accept.ts
@@ -0,0 +1,24 @@
+import { Args, Command, Flags } from '@oclif/core'
+import type { VerificationAcceptResponse } from '@beeper/desktop-api/resources/app/e2ee/verification/verification.js'
+import { appRequest } from '../../../../lib/app-api.js'
+import { printData } from '../../../../lib/output.js'
+
+export default class AppE2EEVerificationAccept extends Command {
+  static override summary = 'Accept a device verification request'
+  static override args = {
+    txnID: Args.string({ description: 'Verification transaction ID', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(AppE2EEVerificationAccept)
+    const result = await appRequest<VerificationAcceptResponse>('POST', '/v1/app/e2ee/verification/accept', {
+      baseURL: flags['base-url'],
+      body: { txnID: args.txnID },
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/e2ee/verification/cancel.ts b/src/commands/app/e2ee/verification/cancel.ts
new file mode 100644
index 0000000..387e7b3
--- /dev/null
+++ b/src/commands/app/e2ee/verification/cancel.ts
@@ -0,0 +1,26 @@
+import { Args, Command, Flags } from '@oclif/core'
+import type { VerificationCancelResponse } from '@beeper/desktop-api/resources/app/e2ee/verification/verification.js'
+import { appRequest } from '../../../../lib/app-api.js'
+import { printData } from '../../../../lib/output.js'
+
+export default class AppE2EEVerificationCancel extends Command {
+  static override summary = 'Cancel device verification'
+  static override args = {
+    txnID: Args.string({ description: 'Verification transaction ID', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    code: Flags.string({ description: 'Optional cancellation code' }),
+    reason: Flags.string({ description: 'Optional cancellation reason' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(AppE2EEVerificationCancel)
+    const result = await appRequest<VerificationCancelResponse>('POST', '/v1/app/e2ee/verification/cancel', {
+      baseURL: flags['base-url'],
+      body: { txnID: args.txnID, code: flags.code, reason: flags.reason },
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/e2ee/verification/qr/confirm-scanned.ts b/src/commands/app/e2ee/verification/qr/confirm-scanned.ts
new file mode 100644
index 0000000..3484fc5
--- /dev/null
+++ b/src/commands/app/e2ee/verification/qr/confirm-scanned.ts
@@ -0,0 +1,24 @@
+import { Args, Command, Flags } from '@oclif/core'
+import type { QrConfirmScannedResponse } from '@beeper/desktop-api/resources/app/e2ee/verification/qr.js'
+import { appRequest } from '../../../../../lib/app-api.js'
+import { printData } from '../../../../../lib/output.js'
+
+export default class AppE2EEVerificationQRConfirmScanned extends Command {
+  static override summary = 'Confirm another device scanned this QR code'
+  static override args = {
+    txnID: Args.string({ description: 'Verification transaction ID', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(AppE2EEVerificationQRConfirmScanned)
+    const result = await appRequest<QrConfirmScannedResponse>('POST', '/v1/app/e2ee/verification/qr/confirm-scanned', {
+      baseURL: flags['base-url'],
+      body: { txnID: args.txnID },
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/e2ee/verification/qr/scan.ts b/src/commands/app/e2ee/verification/qr/scan.ts
new file mode 100644
index 0000000..4d5e3a6
--- /dev/null
+++ b/src/commands/app/e2ee/verification/qr/scan.ts
@@ -0,0 +1,24 @@
+import { Args, Command, Flags } from '@oclif/core'
+import type { QrScanResponse } from '@beeper/desktop-api/resources/app/e2ee/verification/qr.js'
+import { appRequest } from '../../../../../lib/app-api.js'
+import { printData } from '../../../../../lib/output.js'
+
+export default class AppE2EEVerificationQRScan extends Command {
+  static override summary = 'Submit a scanned verification QR payload'
+  static override args = {
+    data: Args.string({ description: 'QR code payload', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(AppE2EEVerificationQRScan)
+    const result = await appRequest<QrScanResponse>('POST', '/v1/app/e2ee/verification/qr/scan', {
+      baseURL: flags['base-url'],
+      body: { data: args.data },
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/e2ee/verification/sas/confirm.ts b/src/commands/app/e2ee/verification/sas/confirm.ts
new file mode 100644
index 0000000..b7504c2
--- /dev/null
+++ b/src/commands/app/e2ee/verification/sas/confirm.ts
@@ -0,0 +1,24 @@
+import { Args, Command, Flags } from '@oclif/core'
+import type { SaConfirmResponse } from '@beeper/desktop-api/resources/app/e2ee/verification/sas.js'
+import { appRequest } from '../../../../../lib/app-api.js'
+import { printData } from '../../../../../lib/output.js'
+
+export default class AppE2EEVerificationSASConfirm extends Command {
+  static override summary = 'Confirm matching emoji verification'
+  static override args = {
+    txnID: Args.string({ description: 'Verification transaction ID', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(AppE2EEVerificationSASConfirm)
+    const result = await appRequest<SaConfirmResponse>('POST', '/v1/app/e2ee/verification/sas/confirm', {
+      baseURL: flags['base-url'],
+      body: { txnID: args.txnID },
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/e2ee/verification/sas/start.ts b/src/commands/app/e2ee/verification/sas/start.ts
new file mode 100644
index 0000000..573e529
--- /dev/null
+++ b/src/commands/app/e2ee/verification/sas/start.ts
@@ -0,0 +1,24 @@
+import { Args, Command, Flags } from '@oclif/core'
+import type { SaStartResponse } from '@beeper/desktop-api/resources/app/e2ee/verification/sas.js'
+import { appRequest } from '../../../../../lib/app-api.js'
+import { printData } from '../../../../../lib/output.js'
+
+export default class AppE2EEVerificationSASStart extends Command {
+  static override summary = 'Start emoji verification'
+  static override args = {
+    txnID: Args.string({ description: 'Verification transaction ID', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(AppE2EEVerificationSASStart)
+    const result = await appRequest<SaStartResponse>('POST', '/v1/app/e2ee/verification/sas/start', {
+      baseURL: flags['base-url'],
+      body: { txnID: args.txnID },
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/e2ee/verification/start.ts b/src/commands/app/e2ee/verification/start.ts
new file mode 100644
index 0000000..57f1804
--- /dev/null
+++ b/src/commands/app/e2ee/verification/start.ts
@@ -0,0 +1,22 @@
+import { Command, Flags } from '@oclif/core'
+import type { VerificationStartResponse } from '@beeper/desktop-api/resources/app/e2ee/verification/verification.js'
+import { appRequest } from '../../../../lib/app-api.js'
+import { printData } from '../../../../lib/output.js'
+
+export default class AppE2EEVerificationStart extends Command {
+  static override summary = 'Start device verification'
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    'user-id': Flags.string({ description: 'User ID to verify. Defaults to the signed-in user.' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(AppE2EEVerificationStart)
+    const result = await appRequest<VerificationStartResponse>('POST', '/v1/app/e2ee/verification', {
+      baseURL: flags['base-url'],
+      body: flags['user-id'] ? { userID: flags['user-id'] } : {},
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/app/status.ts b/src/commands/app/status.ts
new file mode 100644
index 0000000..7194e4d
--- /dev/null
+++ b/src/commands/app/status.ts
@@ -0,0 +1,18 @@
+import { Command, Flags } from '@oclif/core'
+import type { AppStatusResponse } from '@beeper/desktop-api/resources/app/app.js'
+import { appRequest } from '../../lib/app-api.js'
+import { printData } from '../../lib/output.js'
+
+export default class AppStatus extends Command {
+  static override summary = 'Show Beeper app login and encrypted messaging state'
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(AppStatus)
+    const state = await appRequest<AppStatusResponse>('GET', '/v1/app/status', { baseURL: flags['base-url'] })
+    await printData(state, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/archive.ts b/src/commands/archive.ts
new file mode 100644
index 0000000..c3f8847
--- /dev/null
+++ b/src/commands/archive.ts
@@ -0,0 +1,26 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy } from '../lib/copy.js'
+import { printSuccess } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Archive extends Command {
+  static override summary = apiCopy.chats.archive
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Archive)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await client.chats.archive(chatID, { archived: true })
+    await printSuccess({ message: 'Archived', detail: chatID, data: { chatID } }, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/assets/download.ts b/src/commands/assets/download.ts
new file mode 100644
index 0000000..7fe28cd
--- /dev/null
+++ b/src/commands/assets/download.ts
@@ -0,0 +1,23 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../../lib/client.js'
+import { apiCopy, cliCopy } from '../../lib/copy.js'
+import { printData } from '../../lib/output.js'
+
+export default class AssetsDownload extends Command {
+  static override summary = apiCopy.assets.download
+  static override args = {
+    url: Args.string({ description: 'Asset URL', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(AssetsDownload)
+    const client = await createClient(flags)
+    const result = await client.assets.download({ url: args.url })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/assets/upload.ts b/src/commands/assets/upload.ts
new file mode 100644
index 0000000..668ecaf
--- /dev/null
+++ b/src/commands/assets/upload.ts
@@ -0,0 +1,30 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createReadStream } from 'node:fs'
+import { createClient } from '../../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../../lib/copy.js'
+import { printData } from '../../lib/output.js'
+
+export default class AssetsUpload extends Command {
+  static override summary = apiCopy.assets.upload
+  static override args = {
+    file: Args.string({ description: sdkParamCopy.attachmentFile, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    'file-name': Flags.string({ description: sdkParamCopy.fileName }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    'mime-type': Flags.string({ description: sdkParamCopy.mimeType }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(AssetsUpload)
+    const client = await createClient(flags)
+    const result = await client.assets.upload({
+      file: createReadStream(args.file),
+      fileName: flags['file-name'],
+      mimeType: flags['mime-type'],
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/auth/login.tsx b/src/commands/auth/login.tsx
new file mode 100644
index 0000000..dd45606
--- /dev/null
+++ b/src/commands/auth/login.tsx
@@ -0,0 +1,175 @@
+import { Command, Flags } from '@oclif/core'
+import React from 'react'
+import { Box, Text, render as inkRender } from 'ink'
+import { loginWithPKCE } from '../../lib/oauth.js'
+import { readConfig, updateConfig } from '../../lib/config.js'
+import { findLocalDesktop, getDesktopAppStatus } from '../../lib/desktop-auth.js'
+import {
+  type AppLoginOutput,
+  type AppLoginSuccess,
+  appRequest,
+  isRegistrationRequired,
+  promptText,
+  promptYesNo,
+} from '../../lib/app-api.js'
+import { AuthSignedIn } from '../../lib/ink/components.js'
+import { theme, glyphs } from '../../lib/ink/theme.js'
+import { printData } from '../../lib/output.js'
+
+async function showSignedIn(props: React.ComponentProps<typeof AuthSignedIn>): Promise<void> {
+  const instance = inkRender(<AuthSignedIn {...props} />, { exitOnCtrlC: false, patchConsole: false })
+  setTimeout(() => instance.unmount(), 0)
+  await instance.waitUntilExit().catch(() => undefined)
+}
+
+async function showStep(label: string, detail?: string): Promise<void> {
+  const node = (
+    <Box>
+      <Text color={theme.primary}>{glyphs.arrow}</Text>
+      <Text> </Text>
+      <Text color={theme.text}>{label}</Text>
+      {detail ? <Text color={theme.muted}>  {detail}</Text> : null}
+    </Box>
+  )
+  const instance = inkRender(node, { exitOnCtrlC: false, patchConsole: false })
+  setTimeout(() => instance.unmount(), 0)
+  await instance.waitUntilExit().catch(() => undefined)
+}
+
+export default class AuthLogin extends Command {
+  static override summary = 'Authenticate with local Beeper Desktop'
+  static override flags = {
+    'server-url': Flags.string({
+      aliases: ['base-url'],
+      description: 'Beeper Desktop API server URL',
+    }),
+    email: Flags.string({ description: 'Email address to send a sign-in code to' }),
+    code: Flags.string({ description: 'Email sign-in code' }),
+    username: Flags.string({ description: 'Username to create if registration is required' }),
+    'accept-terms': Flags.boolean({ default: false, description: 'Accept the Terms of Use and acknowledge the Privacy Policy when creating an account' }),
+    'app-login': Flags.boolean({ default: false, description: 'Sign in the local Beeper Desktop app itself instead of requesting a Desktop API token from an already signed-in app' }),
+    'no-save': Flags.boolean({ default: false, description: 'Do not store the returned Desktop API token' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+    oauth: Flags.boolean({ default: false, description: 'Use the OAuth2 PKCE Desktop API authorization flow' }),
+    'client-name': Flags.string({ default: 'Beeper CLI', description: 'OAuth client name shown in Beeper Desktop' }),
+    'no-open': Flags.boolean({ default: false, description: 'Print the authorization URL instead of opening a browser' }),
+    scope: Flags.string({ default: 'read write', description: 'Space-separated OAuth scopes' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(AuthLogin)
+    const config = await readConfig()
+    const desktop = await findLocalDesktop({
+      baseURL: flags['server-url'] ?? config.baseURL,
+      scan: !flags['server-url'],
+    })
+    const baseURL = desktop.baseURL
+
+    const useAppLogin = flags['app-login']
+      || Boolean(flags.email || flags.code || flags.username || flags['accept-terms'])
+
+    if (!useAppLogin && !flags.oauth && await this.shouldUseAppLogin(baseURL)) {
+      throw new Error('Beeper Desktop is not signed in. Open Beeper Desktop and sign in, then rerun this command, or pass --app-login to sign in the app itself.')
+    }
+
+    if (!useAppLogin || flags.oauth) {
+      const token = await loginWithPKCE({
+        baseURL,
+        clientName: flags['client-name'],
+        openBrowser: !flags['no-open'],
+        save: !flags['no-save'],
+        scope: flags.scope,
+      })
+      if (flags.json) {
+        await printData(token, 'json')
+        return
+      }
+      const detail = token.expires_in ? `token expires in ${token.expires_in}s` : undefined
+      await showSignedIn({ as: token.clientID, detail, saved: !flags['no-save'] })
+      return
+    }
+
+    if (!flags.json) await showStep('Starting email sign-in', baseURL)
+    const start = await appRequest<{ request: string; type: string[] }>('POST', '/v1/app/login/start', {
+      baseURL,
+      token: false,
+    })
+    const email = flags.email ?? await promptText('Email: ')
+    if (!flags.json) await showStep('Sending one-time code', email)
+    await appRequest<Record<string, never>>('POST', '/v1/app/login/email', {
+      baseURL,
+      token: false,
+      body: { request: start.request, email },
+    })
+    const code = flags.code ?? await promptText('Code: ')
+    if (!flags.json) await showStep('Verifying code')
+    let result = await appRequest<AppLoginOutput>('POST', '/v1/app/login/response', {
+      baseURL,
+      token: false,
+      body: { request: start.request, response: code },
+    })
+
+    if (isRegistrationRequired(result)) {
+      result = await this.register(baseURL, result, flags)
+    }
+
+    await this.finishLogin(baseURL, result, { json: flags.json, save: !flags['no-save'] })
+  }
+
+  private async shouldUseAppLogin(baseURL: string): Promise<boolean> {
+    const status = await getDesktopAppStatus(baseURL)
+    return status?.state === 'needs-login'
+  }
+
+  private async register(
+    baseURL: string,
+    required: Extract<AppLoginOutput, { registrationRequired: true }>,
+    flags: { username?: string; 'accept-terms': boolean; json?: boolean },
+  ): Promise<AppLoginSuccess> {
+    if (!flags.json && required.copy?.title) await showStep(required.copy.title)
+    if (!flags.json && required.usernameSuggestions?.length) {
+      await showStep('Suggestions', required.usernameSuggestions.join(', '))
+    }
+    const username = flags.username ?? await promptText(`${required.copy?.usernamePlaceholder ?? 'Username'}: `)
+    const accepted = flags['accept-terms'] || await promptYesNo(required.copy?.terms ?? 'Accept Terms of Use and acknowledge Privacy Policy?')
+    if (!accepted) throw new Error('Account creation requires --accept-terms or an interactive yes response.')
+    return appRequest<AppLoginSuccess>('POST', '/v1/app/login/register', {
+      baseURL,
+      token: false,
+      body: {
+        request: required.request,
+        leadToken: required.leadToken,
+        username,
+        acceptTerms: true,
+      },
+    })
+  }
+
+  private async finishLogin(
+    baseURL: string,
+    result: AppLoginSuccess,
+    options: { json: boolean; save: boolean },
+  ): Promise<void> {
+    if (options.save) {
+      await updateConfig(config => ({
+        ...config,
+        baseURL,
+        auth: {
+          accessToken: result.desktopAPI.accessToken,
+          scope: result.desktopAPI.scope,
+          tokenType: result.desktopAPI.tokenType,
+        },
+      }))
+    }
+
+    if (options.json) {
+      await printData(result, 'json')
+      return
+    }
+    await showSignedIn({
+      as: result.matrix.userID,
+      detail: `app state: ${result.appState.state}`,
+      saved: options.save,
+    })
+  }
+}
diff --git a/src/commands/auth/logout.ts b/src/commands/auth/logout.ts
new file mode 100644
index 0000000..3f9540d
--- /dev/null
+++ b/src/commands/auth/logout.ts
@@ -0,0 +1,31 @@
+import { Command, Flags } from '@oclif/core'
+import { readConfig, updateConfig } from '../../lib/config.js'
+import { printSuccess } from '../../lib/output.js'
+
+export default class AuthLogout extends Command {
+  static override summary = 'Remove the locally stored Beeper Desktop token'
+  static override flags = {
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(AuthLogout)
+    const config = await readConfig()
+    const token = config.auth?.accessToken
+    let revoked = false
+    if (token) {
+      const response = await fetch(new URL('/oauth/revoke', config.baseURL), {
+        method: 'POST',
+        headers: { 'content-type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({ token, token_type_hint: 'access_token' }),
+      }).catch(() => undefined)
+      revoked = Boolean(response?.ok)
+    }
+    await updateConfig(current => ({ ...current, auth: undefined }))
+    await printSuccess({
+      message: 'Logged out',
+      detail: revoked ? 'token revoked on server' : token ? 'local token cleared (server revoke failed silently)' : 'no token was stored',
+      data: { revoked, hadToken: Boolean(token) },
+    }, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/auth/status.ts b/src/commands/auth/status.ts
new file mode 100644
index 0000000..fe2c184
--- /dev/null
+++ b/src/commands/auth/status.ts
@@ -0,0 +1,25 @@
+import { Command, Flags } from '@oclif/core'
+import { readConfig } from '../../lib/config.js'
+import { printData } from '../../lib/output.js'
+
+export default class AuthStatus extends Command {
+  static override summary = 'Show local auth status and token metadata'
+  static override flags = {
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(AuthStatus)
+    const config = await readConfig()
+    const authenticated = Boolean(process.env.BEEPER_ACCESS_TOKEN || config.auth?.accessToken)
+    const data = {
+      authenticated,
+      baseURL: config.baseURL,
+      source: process.env.BEEPER_ACCESS_TOKEN ? 'env' : config.auth?.accessToken ? 'config' : 'none',
+      clientID: config.auth?.clientID,
+      expiresAt: config.auth?.expiresAt,
+      scope: config.auth?.scope,
+    }
+    await printData(data, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/avatar.ts b/src/commands/avatar.ts
new file mode 100644
index 0000000..b75879f
--- /dev/null
+++ b/src/commands/avatar.ts
@@ -0,0 +1,29 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Avatar extends Command {
+  static override summary = 'Set or clear a group chat avatar'
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    path: Args.string({ description: 'Local avatar image path. Omit with --clear to remove it.', required: false }),
+  }
+
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    clear: Flags.boolean({ default: false, description: 'Clear the current avatar' }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Avatar)
+    if (!flags.clear && !args.path) throw new Error('Provide PATH or pass --clear')
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await printData(await client.chats.update(chatID, { imgURL: flags.clear ? null : args.path }), flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/chat.ts b/src/commands/chat.ts
new file mode 100644
index 0000000..d8de3ac
--- /dev/null
+++ b/src/commands/chat.ts
@@ -0,0 +1,29 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Chat extends Command {
+  static override summary = apiCopy.chats.retrieve
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    'max-participants': Flags.integer({ description: 'Maximum participants to return' }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Chat)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const chat = await client.chats.retrieve(chatID, {
+      maxParticipantCount: flags['max-participants'],
+    })
+    await printData(chat, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/chat/open.ts b/src/commands/chat/open.ts
new file mode 100644
index 0000000..8fff7af
--- /dev/null
+++ b/src/commands/chat/open.ts
@@ -0,0 +1 @@
+export { default } from '../focus.js'
diff --git a/src/commands/chats/index.ts b/src/commands/chats/index.ts
new file mode 100644
index 0000000..a693d06
--- /dev/null
+++ b/src/commands/chats/index.ts
@@ -0,0 +1,43 @@
+import { Command, Flags } from '@oclif/core'
+import { createClient } from '../../lib/client.js'
+import { apiCopy, cliCopy } from '../../lib/copy.js'
+import { collectPage, printIDs, printList } from '../../lib/output.js'
+import { resolveAccountIDs } from '../../lib/resolve.js'
+import { withSpinner } from '../../lib/ui.js'
+
+export default class ChatsIndex extends Command {
+  static override summary = apiCopy.chats.list
+  static override flags = {
+    account: Flags.string({ multiple: true, description: `Limit to ${cliCopy.args.accountSelector}` }),
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    ids: Flags.boolean({ default: false, description: 'Print only chat IDs' }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    limit: Flags.integer({ default: 20, description: 'Maximum chats to print' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(ChatsIndex)
+    const client = await createClient(flags)
+    const accountIDs = await resolveAccountIDs(client, flags.account, { allowMultiplePerInput: true })
+    const useSpinner = !flags.json && !flags.ids
+    const items = useSpinner
+      ? await withSpinner('Loading chats…', () => collectPage(client.chats.list({ accountIDs }), flags.limit), {
+        done: value => `${value.length} chat${value.length === 1 ? '' : 's'}`,
+      })
+      : await collectPage(client.chats.list({ accountIDs }), flags.limit)
+    if (flags.ids) {
+      printIDs(items)
+      return
+    }
+    printList(items, flags.json ? 'json' : 'human', {
+      title: 'No chats yet',
+      subtitle: accountIDs?.length ? 'Try another account, or check your filters.' : 'Connect an account or sync your existing ones.',
+      suggestions: [
+        { command: 'beeper accounts', hint: 'list connected accounts' },
+        { command: 'beeper accounts add', hint: 'add a new account' },
+        { command: 'beeper status', hint: 'verify Desktop is reachable' },
+      ],
+    })
+  }
+}
diff --git a/src/commands/chats/search.ts b/src/commands/chats/search.ts
new file mode 100644
index 0000000..1d1b729
--- /dev/null
+++ b/src/commands/chats/search.ts
@@ -0,0 +1,64 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../../lib/copy.js'
+import { collectPage, printIDs, printList } from '../../lib/output.js'
+import { resolveAccountIDs } from '../../lib/resolve.js'
+import { withSpinner } from '../../lib/ui.js'
+
+export default class ChatsSearch extends Command {
+  static override summary = apiCopy.chats.search
+  static override args = {
+    query: Args.string({ description: sdkParamCopy.searchQuery, required: true }),
+  }
+  static override flags = {
+    account: Flags.string({ multiple: true, description: `Limit to ${cliCopy.args.accountSelector}` }),
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    ids: Flags.boolean({ default: false, description: 'Print only chat IDs' }),
+    inbox: Flags.string({ options: ['primary', 'low-priority', 'archive'] }),
+    'include-muted': Flags.boolean({ allowNo: true, description: 'Include muted chats. Use --no-include-muted for a tighter search.' }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    'last-activity-after': Flags.string({ description: 'Only chats with last activity after this ISO timestamp' }),
+    'last-activity-before': Flags.string({ description: 'Only chats with last activity before this ISO timestamp' }),
+    limit: Flags.integer({ default: 20, description: 'Maximum chats to print' }),
+    scope: Flags.string({ options: ['titles', 'participants'] }),
+    type: Flags.string({ options: ['single', 'group', 'any'] }),
+    unread: Flags.boolean({ default: false, description: 'Only unread chats' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(ChatsSearch)
+    const client = await createClient(flags)
+    const accountIDs = await resolveAccountIDs(client, flags.account, { allowMultiplePerInput: true })
+    const params = {
+      accountIDs,
+      inbox: flags.inbox as 'primary' | 'low-priority' | 'archive' | undefined,
+      includeMuted: flags['include-muted'],
+      lastActivityAfter: flags['last-activity-after'],
+      lastActivityBefore: flags['last-activity-before'],
+      query: args.query,
+      scope: flags.scope as 'titles' | 'participants' | undefined,
+      type: flags.type as 'single' | 'group' | 'any' | undefined,
+      unreadOnly: flags.unread || undefined,
+    }
+    const useSpinner = !flags.json && !flags.ids
+    const items = useSpinner
+      ? await withSpinner(`Searching chats for "${args.query}"…`, () => collectPage(client.chats.search(params), flags.limit), {
+        done: value => `${value.length} match${value.length === 1 ? '' : 'es'}`,
+      })
+      : await collectPage(client.chats.search(params), flags.limit)
+    if (flags.ids) {
+      printIDs(items)
+      return
+    }
+    printList(items, flags.json ? 'json' : 'human', {
+      title: 'No chats matched',
+      subtitle: `Nothing found for "${args.query}".`,
+      suggestions: [
+        { command: 'beeper chats', hint: 'see everything' },
+        { command: 'beeper search "<term>"', hint: 'search messages too' },
+        { command: 'beeper contacts <accountID> <query>', hint: 'find contacts to start a chat' },
+      ],
+    })
+  }
+}
diff --git a/src/commands/clear-draft.ts b/src/commands/clear-draft.ts
new file mode 100644
index 0000000..fa9a67a
--- /dev/null
+++ b/src/commands/clear-draft.ts
@@ -0,0 +1,25 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class ClearDraft extends Command {
+  static override summary = 'Clear a chat draft'
+  static override args = {
+    chat: Args.string({ description: 'Chat ID, local chat ID, title, or search text', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+    pick: Flags.integer({ description: 'Pick the Nth chat when the input is ambiguous' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(ClearDraft)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const result = await client.chats.update(chatID, { draft: null })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/commands.ts b/src/commands/commands.ts
new file mode 100644
index 0000000..f2a44c9
--- /dev/null
+++ b/src/commands/commands.ts
@@ -0,0 +1,15 @@
+import { Command, Flags } from '@oclif/core'
+import { commandManifest } from '../lib/manifest.js'
+import { printData } from '../lib/output.js'
+
+export default class Commands extends Command {
+  static override summary = 'Print the Beeper CLI command manifest'
+  static override flags = {
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(Commands)
+    await printData(commandManifest, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/config/get.ts b/src/commands/config/get.ts
new file mode 100644
index 0000000..a4b39d8
--- /dev/null
+++ b/src/commands/config/get.ts
@@ -0,0 +1,24 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { readConfig } from '../../lib/config.js'
+import { printConfig, printData } from '../../lib/output.js'
+
+export default class ConfigGet extends Command {
+  static override summary = 'Print CLI configuration'
+  static override args = {
+    key: Args.string({ description: 'Optional config key to print', options: ['baseURL', 'auth'], required: false }),
+  }
+  static override flags = {
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(ConfigGet)
+    const config = await readConfig()
+    const format = flags.json ? 'json' : 'human'
+    if (args.key) {
+      await printData(config[args.key as 'baseURL' | 'auth'], format)
+      return
+    }
+    await printConfig(config as unknown as Record<string, unknown>, format)
+  }
+}
diff --git a/src/commands/config/path.ts b/src/commands/config/path.ts
new file mode 100644
index 0000000..3a759eb
--- /dev/null
+++ b/src/commands/config/path.ts
@@ -0,0 +1,20 @@
+import { Command, Flags } from '@oclif/core'
+import { configPath } from '../../lib/config.js'
+
+export default class ConfigPath extends Command {
+  static override summary = 'Print the CLI config path'
+  static override flags = {
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(ConfigPath)
+    const path = configPath()
+    if (flags.json) {
+      process.stdout.write(`${JSON.stringify({ path }, null, 2)}\n`)
+      return
+    }
+    // Plain path so it's pipeable (xargs / cat / cd).
+    process.stdout.write(`${path}\n`)
+  }
+}
diff --git a/src/commands/config/reset.ts b/src/commands/config/reset.ts
new file mode 100644
index 0000000..e6e1bf6
--- /dev/null
+++ b/src/commands/config/reset.ts
@@ -0,0 +1,16 @@
+import { Command, Flags } from '@oclif/core'
+import { resetConfig } from '../../lib/config.js'
+import { printSuccess } from '../../lib/output.js'
+
+export default class ConfigReset extends Command {
+  static override summary = 'Reset CLI configuration'
+  static override flags = {
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(ConfigReset)
+    await resetConfig()
+    await printSuccess({ message: 'Config reset' }, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/config/set.ts b/src/commands/config/set.ts
new file mode 100644
index 0000000..fa87ef7
--- /dev/null
+++ b/src/commands/config/set.ts
@@ -0,0 +1,24 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { updateConfig } from '../../lib/config.js'
+import { printSuccess } from '../../lib/output.js'
+
+export default class ConfigSet extends Command {
+  static override summary = 'Set a CLI configuration value'
+  static override args = {
+    key: Args.string({ description: 'Config key to set', options: ['baseURL'], required: true }),
+    value: Args.string({ description: 'Config value', required: true }),
+  }
+  static override flags = {
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(ConfigSet)
+    await updateConfig(config => ({ ...config, [args.key]: args.value }))
+    await printSuccess({
+      message: `Set ${args.key}`,
+      detail: args.value,
+      data: { [args.key]: args.value },
+    }, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/contacts/list.ts b/src/commands/contacts/list.ts
new file mode 100644
index 0000000..fa67176
--- /dev/null
+++ b/src/commands/contacts/list.ts
@@ -0,0 +1,59 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../../lib/client.js'
+import { apiCopy, cliCopy } from '../../lib/copy.js'
+import { collectPage, printData, printIDs, printList } from '../../lib/output.js'
+import { resolveAccountIDs } from '../../lib/resolve.js'
+import { withSpinner } from '../../lib/ui.js'
+
+export default class ContactsList extends Command {
+  static override summary = apiCopy.contacts.list
+  static override args = {
+    account: Args.string({ description: cliCopy.args.accountSelector, required: true }),
+  }
+
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    ids: Flags.boolean({ default: false, description: 'Print only contact user IDs' }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    limit: Flags.integer({ default: 50, description: 'Maximum contacts to print' }),
+    query: Flags.string({ description: 'Optional blended contact lookup query' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(ContactsList)
+    const client = await createClient(flags)
+    const accountIDs = await resolveAccountIDs(client, [args.account], { allowMultiplePerInput: true }) ?? [args.account]
+    const useSpinner = !flags.json && !flags.ids
+    const load = async (): Promise<Array<Record<string, unknown>>> => {
+      const collected: Array<Record<string, unknown>> = []
+      for (const accountID of accountIDs) {
+        const contacts = await collectPage(client.accounts.contacts.list(accountID, { query: flags.query }), flags.limit)
+        collected.push(...contacts.map(item => ({ ...(item as unknown as Record<string, unknown>), accountID })))
+        if (collected.length >= flags.limit) break
+      }
+      return collected
+    }
+    const items = useSpinner
+      ? await withSpinner(`Loading contacts${flags.query ? ` matching "${flags.query}"` : ''}…`, load, {
+        done: value => `${value.length} contact${value.length === 1 ? '' : 's'}`,
+      })
+      : await load()
+    if (flags.ids) {
+      printIDs(items)
+      return
+    }
+    if (flags.json) {
+      await printData({ items }, 'json')
+      return
+    }
+    await printList(items, 'human', {
+      title: 'No contacts found',
+      subtitle: flags.query ? `Nothing matched "${flags.query}".` : 'This account has no contacts to list.',
+      suggestions: [
+        { command: `beeper contacts ${args.account} <query>`, hint: 'narrow with a search' },
+        { command: 'beeper accounts', hint: 'check the account is online' },
+      ],
+    })
+  }
+}
diff --git a/src/commands/contacts/search.ts b/src/commands/contacts/search.ts
new file mode 100644
index 0000000..6612dc1
--- /dev/null
+++ b/src/commands/contacts/search.ts
@@ -0,0 +1,55 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../../lib/client.js'
+import { apiCopy, cliCopy } from '../../lib/copy.js'
+import { printData, printList } from '../../lib/output.js'
+import { listAccountIDs, resolveAccountIDs } from '../../lib/resolve.js'
+import { withSpinner } from '../../lib/ui.js'
+
+export default class ContactsSearch extends Command {
+  static override summary = apiCopy.contacts.search
+  static override args = {
+    query: Args.string({ description: 'Contact search query', required: true }),
+  }
+  static override flags = {
+    account: Flags.string({ multiple: true, description: `${cliCopy.args.accountSelector}. Omit to search every account.` }),
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(ContactsSearch)
+    const client = await createClient(flags)
+    const accountIDs = await resolveAccountIDs(client, flags.account, { allowMultiplePerInput: true }) ?? await listAccountIDs(client)
+    const load = async (): Promise<Array<Record<string, unknown>>> => {
+      const collected: Array<Record<string, unknown>> = []
+      for (const accountID of accountIDs) {
+        try {
+          const result = await client.accounts.contacts.search(accountID, { query: args.query })
+          collected.push(...result.items.map((item: unknown) => ({ ...(item as Record<string, unknown>), accountID })))
+        } catch {
+          // Some networks reject exact lookups for some identifiers; keep trying the rest.
+        }
+      }
+      return collected
+    }
+    const useSpinner = !flags.json
+    const results = useSpinner
+      ? await withSpinner(`Searching contacts for "${args.query}"…`, load, {
+        done: value => `${value.length} match${value.length === 1 ? '' : 'es'} across ${accountIDs.length} account${accountIDs.length === 1 ? '' : 's'}`,
+      })
+      : await load()
+    if (flags.json) {
+      await printData({ items: results }, 'json')
+      return
+    }
+    await printList(results, 'human', {
+      title: 'No contacts matched',
+      subtitle: `Nothing across your ${accountIDs.length} account${accountIDs.length === 1 ? '' : 's'} matched "${args.query}".`,
+      suggestions: [
+        { command: 'beeper accounts', hint: 'verify which accounts are connected' },
+        { command: `beeper contact <accountID> ${args.query}`, hint: 'exact lookup on one account' },
+      ],
+    })
+  }
+}
diff --git a/src/commands/create-chat.ts b/src/commands/create-chat.ts
new file mode 100644
index 0000000..cbf9118
--- /dev/null
+++ b/src/commands/create-chat.ts
@@ -0,0 +1,33 @@
+import { Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveAccountID } from '../lib/resolve.js'
+
+export default class CreateChat extends Command {
+  static override summary = apiCopy.chats.create
+  static override flags = {
+    account: Flags.string({ description: cliCopy.args.accountSelector, required: true }),
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    message: Flags.string({ description: 'Optional first message' }),
+    participant: Flags.string({ multiple: true, required: true, description: 'Participant user ID' }),
+    title: Flags.string({ description: 'Group title' }),
+    type: Flags.string({ default: 'single', options: ['single', 'group'], description: 'Chat type' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(CreateChat)
+    const client = await createClient(flags)
+    const accountID = await resolveAccountID(client, flags.account)
+    const result = await client.chats.create({
+      accountID,
+      messageText: flags.message,
+      participantIDs: flags.participant,
+      title: flags.title,
+      type: flags.type as 'single' | 'group',
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/current-user.ts b/src/commands/current-user.ts
new file mode 100644
index 0000000..666634c
--- /dev/null
+++ b/src/commands/current-user.ts
@@ -0,0 +1,17 @@
+import { Command, Flags } from '@oclif/core'
+import { appRequest } from '../lib/app-api.js'
+import { printData } from '../lib/output.js'
+
+export default class CurrentUser extends Command {
+  static override summary = 'Show the authenticated Desktop API user'
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(CurrentUser)
+    const user = await appRequest<unknown>('GET', '/oauth/userinfo', { baseURL: flags['base-url'] })
+    await printData(user, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/delete-message.ts b/src/commands/delete-message.ts
new file mode 100644
index 0000000..7c14677
--- /dev/null
+++ b/src/commands/delete-message.ts
@@ -0,0 +1,35 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printSuccess } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class DeleteMessage extends Command {
+  static override summary = apiCopy.messages.delete
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    message: Args.string({ description: sdkParamCopy.messageID, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    'for-everyone': Flags.boolean({ default: false, description: sdkParamCopy.forEveryone }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(DeleteMessage)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await client.messages.delete(args.message, {
+      chatID,
+      forEveryone: flags['for-everyone'] || undefined,
+    })
+    await printSuccess({
+      message: flags['for-everyone'] ? 'Deleted for everyone' : 'Deleted',
+      detail: args.message,
+      data: { messageID: args.message, chatID, forEveryone: flags['for-everyone'] },
+    }, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/description.ts b/src/commands/description.ts
new file mode 100644
index 0000000..1116dbb
--- /dev/null
+++ b/src/commands/description.ts
@@ -0,0 +1,29 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Description extends Command {
+  static override summary = 'Set or clear a group chat description'
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    description: Args.string({ description: 'New description. Omit with --clear to remove it.', required: false }),
+  }
+
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    clear: Flags.boolean({ default: false, description: 'Clear the current description' }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Description)
+    if (!flags.clear && !args.description) throw new Error('Provide DESCRIPTION or pass --clear')
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await printData(await client.chats.update(chatID, { description: flags.clear ? null : args.description }), flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/doctor.ts b/src/commands/doctor.ts
new file mode 100644
index 0000000..c6d6e7b
--- /dev/null
+++ b/src/commands/doctor.ts
@@ -0,0 +1,63 @@
+import { Command, Flags } from '@oclif/core'
+import { createClient, requireToken } from '../lib/client.js'
+import { readConfig } from '../lib/config.js'
+import { printData } from '../lib/output.js'
+import { createSpinner } from '../lib/ui.js'
+
+type Check = { ok: boolean; name: string; detail?: string }
+
+export default class Doctor extends Command {
+  static override summary = 'Verify Desktop API reachability and authentication'
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(Doctor)
+    const config = await readConfig()
+    const baseURL = flags['base-url'] ?? config.baseURL
+    const showSpinners = !flags.json && process.stderr.isTTY
+
+    const checks: Check[] = []
+    const runCheck = async <T>(name: string, label: string, action: () => Promise<T>, success?: (value: T) => string): Promise<void> => {
+      const spinner = showSpinners ? createSpinner(label) : undefined
+      try {
+        const value = await action()
+        const detail = success?.(value)
+        checks.push({ ok: true, name, detail })
+        if (spinner) await spinner.succeed(detail ? `${label.replace(/…$/, '')} — ${detail}` : label.replace(/…$/, ''))
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : String(error)
+        checks.push({ ok: false, name, detail })
+        if (spinner) await spinner.fail(`${label.replace(/…$/, '')} — ${detail}`)
+      }
+    }
+
+    await runCheck('server', 'Checking Beeper Desktop server…', async () => {
+      const response = await fetch(new URL('/v1/info', baseURL))
+      if (!response.ok) throw new Error(`${response.status} ${response.statusText}`)
+      return `${response.status} ${response.statusText}`
+    }, value => value)
+
+    await runCheck('token', 'Checking auth token…', async () => {
+      await requireToken()
+      return process.env.BEEPER_ACCESS_TOKEN ? 'env' : 'config'
+    }, value => `loaded from ${value}`)
+
+    await runCheck('authenticated-request', 'Calling authenticated endpoint…', async () => {
+      const client = await createClient({ ...flags, baseURL })
+      await client.accounts.list()
+      return 'ok'
+    })
+
+    const result = { ok: checks.every(check => check.ok), checks }
+    if (flags.json) {
+      await printData(result, 'json')
+    } else {
+      await printData(result, 'human')
+    }
+    if (!result.ok) this.exit(1)
+  }
+}
diff --git a/src/commands/draft.ts b/src/commands/draft.ts
new file mode 100644
index 0000000..af31988
--- /dev/null
+++ b/src/commands/draft.ts
@@ -0,0 +1,52 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createReadStream } from 'node:fs'
+import { createClient } from '../lib/client.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Draft extends Command {
+  static override summary = 'Set a chat draft'
+  static override args = {
+    chat: Args.string({ description: 'Chat ID, local chat ID, title, or search text', required: true }),
+    text: Args.string({ description: 'Draft text', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    debug: Flags.boolean({ default: false }),
+    file: Flags.string({ description: 'Draft attachment file' }),
+    'file-name': Flags.string({ description: 'Attachment display filename' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+    'mime-type': Flags.string({ description: 'Attachment MIME type' }),
+    pick: Flags.integer({ description: 'Pick the Nth chat when the input is ambiguous' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Draft)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const upload = flags.file
+      ? await client.assets.upload({
+        file: createReadStream(flags.file),
+        fileName: flags['file-name'],
+        mimeType: flags['mime-type'],
+      })
+      : undefined
+    const result = await client.chats.update(chatID, {
+      draft: {
+        text: args.text,
+        attachments: upload?.uploadID
+          ? {
+            [upload.uploadID]: {
+              uploadID: upload.uploadID,
+              duration: upload.duration,
+              fileName: upload.fileName,
+              mimeType: upload.mimeType,
+              size: upload.width && upload.height ? { height: upload.height, width: upload.width } : undefined,
+            },
+          }
+          : undefined,
+      },
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/edit.ts b/src/commands/edit.ts
new file mode 100644
index 0000000..877774f
--- /dev/null
+++ b/src/commands/edit.ts
@@ -0,0 +1,31 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Edit extends Command {
+  static override summary = apiCopy.messages.update
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    message: Args.string({ description: sdkParamCopy.messageID, required: true }),
+    text: Args.string({ description: sdkParamCopy.text, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Edit)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const result = await client.messages.update(args.message, {
+      chatID,
+      text: args.text,
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/export.ts b/src/commands/export.ts
new file mode 100644
index 0000000..5f10422
--- /dev/null
+++ b/src/commands/export.ts
@@ -0,0 +1,50 @@
+import { Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { exportBeeperData } from '../lib/export/index.js'
+import { resolveAccountIDs, resolveChatID } from '../lib/resolve.js'
+
+export default class Export extends Command {
+  static override summary = 'Export accounts, chats, messages, Markdown transcripts, and attachments.'
+  static override description = [
+    'Creates a resumable Beeper Desktop export using the official Desktop API SDK.',
+    'The export directory contains accounts.json, chats.json, manifest.json, and one directory per chat with chat.json, messages.json, messages.markdown, messages.html, downloaded attachments, and checkpoint state for interrupted runs.',
+  ].join('\n')
+
+  static override flags = {
+    account: Flags.string({ multiple: true, description: 'Limit to an account selector. Repeat to include more accounts.' }),
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    chat: Flags.string({ multiple: true, description: 'Limit to a chat selector. Repeat to include more chats.' }),
+    debug: Flags.boolean({ default: false }),
+    force: Flags.boolean({ default: false, description: 'Re-export chats even if checkpoint state says they are complete.' }),
+    'limit-chats': Flags.integer({ description: 'Maximum chats to export. Intended for testing large exports.' }),
+    'limit-messages': Flags.integer({ description: 'Maximum messages per chat. Intended for testing large exports.' }),
+    'max-participants': Flags.integer({ default: 500, description: 'Maximum participants to include in each chat.json.' }),
+    'no-attachments': Flags.boolean({ default: false, description: 'Skip downloading message attachments.' }),
+    out: Flags.directory({ char: 'o', default: 'beeper-export', description: 'Export directory.' }),
+    pick: Flags.integer({ description: 'Pick the Nth chat when a --chat selector is ambiguous.' }),
+    quiet: Flags.boolean({ default: false, description: 'Suppress progress output.' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(Export)
+    const client = await createClient(flags)
+    const accountIDs = await resolveAccountIDs(client, flags.account, { allowMultiplePerInput: true })
+    const chatIDs = flags.chat?.length
+      ? await Promise.all(flags.chat.map(chat => resolveChatID(client, chat, { accountIDs, pick: flags.pick })))
+      : undefined
+
+    const manifest = await exportBeeperData(client, {
+      accountIDs,
+      chatIDs,
+      downloadAttachments: !flags['no-attachments'],
+      force: flags.force,
+      limitChats: flags['limit-chats'],
+      limitMessages: flags['limit-messages'],
+      maxParticipants: flags['max-participants'],
+      outDir: flags.out,
+      quiet: flags.quiet,
+    })
+
+    this.log(`Exported ${manifest.chatCount} chats, ${manifest.messageCount} messages, ${manifest.attachmentCount} attachments to ${flags.out}`)
+  }
+}
diff --git a/src/commands/focus.ts b/src/commands/focus.ts
new file mode 100644
index 0000000..cf9ea3f
--- /dev/null
+++ b/src/commands/focus.ts
@@ -0,0 +1,33 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Focus extends Command {
+  static override summary = 'Focus Beeper Desktop, optionally opening a chat or message'
+  static override args = {
+    chat: Args.string({ description: 'Chat ID, local chat ID, title, or search text', required: false }),
+    message: Args.string({ description: 'Message ID', required: false }),
+  }
+  static override flags = {
+    attachment: Flags.string({ description: 'Draft attachment path' }),
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    debug: Flags.boolean({ default: false }),
+    draft: Flags.string({ description: 'Draft text' }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+    pick: Flags.integer({ description: 'Pick the Nth chat when the input is ambiguous' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Focus)
+    const client = await createClient(flags)
+    const chatID = args.chat ? await resolveChatID(client, args.chat, { pick: flags.pick }) : undefined
+    const result = await client.focus({
+      chatID,
+      draftAttachmentPath: flags.attachment,
+      draftText: flags.draft,
+      messageID: args.message,
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/inbox.ts b/src/commands/inbox.ts
new file mode 100644
index 0000000..1a209b5
--- /dev/null
+++ b/src/commands/inbox.ts
@@ -0,0 +1,26 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Inbox extends Command {
+  static override summary = 'Move a chat to the primary inbox'
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Inbox)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await printData(await client.chats.update(chatID, { isArchived: false, isLowPriority: false }), flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/llm.ts b/src/commands/llm.ts
new file mode 100644
index 0000000..1c640a5
--- /dev/null
+++ b/src/commands/llm.ts
@@ -0,0 +1,21 @@
+import { Command, Flags } from '@oclif/core'
+import { commandManifest } from '../lib/manifest.js'
+import { printCommands } from '../lib/output.js'
+
+export default class LLM extends Command {
+  static override summary = 'Print compact CLI help for agents'
+  static override flags = {
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(LLM)
+    await printCommands(commandManifest, flags.json ? 'json' : 'human', {
+      title: 'Beeper CLI',
+      intro: [
+        'Auth: beeper login',
+        'Most commands accept --json. List commands accept --limit.',
+      ],
+    })
+  }
+}
diff --git a/src/commands/login.ts b/src/commands/login.ts
new file mode 100644
index 0000000..316d57e
--- /dev/null
+++ b/src/commands/login.ts
@@ -0,0 +1,3 @@
+import AuthLogin from './auth/login.js'
+
+export default AuthLogin
diff --git a/src/commands/logout.ts b/src/commands/logout.ts
new file mode 100644
index 0000000..e6e911b
--- /dev/null
+++ b/src/commands/logout.ts
@@ -0,0 +1,3 @@
+import AuthLogout from './auth/logout.js'
+
+export default AuthLogout
diff --git a/src/commands/low-priority.ts b/src/commands/low-priority.ts
new file mode 100644
index 0000000..3aa932e
--- /dev/null
+++ b/src/commands/low-priority.ts
@@ -0,0 +1,26 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class LowPriority extends Command {
+  static override summary = 'Move a chat to Low Priority'
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(LowPriority)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await printData(await client.chats.update(chatID, { isLowPriority: true }), flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/mark-read.ts b/src/commands/mark-read.ts
new file mode 100644
index 0000000..d41eeb6
--- /dev/null
+++ b/src/commands/mark-read.ts
@@ -0,0 +1 @@
+export { default } from './read.js'
diff --git a/src/commands/mark-unread.ts b/src/commands/mark-unread.ts
new file mode 100644
index 0000000..759dba1
--- /dev/null
+++ b/src/commands/mark-unread.ts
@@ -0,0 +1 @@
+export { default } from './unread.js'
diff --git a/src/commands/message-expiry.ts b/src/commands/message-expiry.ts
new file mode 100644
index 0000000..3390e5e
--- /dev/null
+++ b/src/commands/message-expiry.ts
@@ -0,0 +1,29 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class MessageExpiry extends Command {
+  static override summary = 'Set or clear disappearing-message expiry'
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    seconds: Args.string({ description: 'Expiry in seconds, or "off"', required: true }),
+  }
+
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(MessageExpiry)
+    const expiry = args.seconds.toLowerCase() === 'off' ? null : Number(args.seconds)
+    if (expiry !== null && (!Number.isInteger(expiry) || expiry < 0)) throw new Error('SECONDS must be a positive integer or "off"')
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await printData(await client.chats.update(chatID, { messageExpirySeconds: expiry }), flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/message.ts b/src/commands/message.ts
new file mode 100644
index 0000000..23e237b
--- /dev/null
+++ b/src/commands/message.ts
@@ -0,0 +1,27 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Message extends Command {
+  static override summary = apiCopy.messages.retrieve
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    message: Args.string({ description: sdkParamCopy.messageID, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Message)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const result = await client.messages.retrieve(args.message, { chatID })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/messages/index.ts b/src/commands/messages/index.ts
new file mode 100644
index 0000000..d4a2719
--- /dev/null
+++ b/src/commands/messages/index.ts
@@ -0,0 +1,49 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../../lib/client.js'
+import { apiCopy, cliCopy } from '../../lib/copy.js'
+import { collectPage, printIDs, printList } from '../../lib/output.js'
+import { resolveChatID } from '../../lib/resolve.js'
+import { withSpinner } from '../../lib/ui.js'
+
+export default class MessagesIndex extends Command {
+  static override summary = apiCopy.messages.list
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    before: Flags.string({ description: 'Fetch messages before cursor' }),
+    after: Flags.string({ description: 'Fetch messages after cursor' }),
+    debug: Flags.boolean({ default: false }),
+    ids: Flags.boolean({ default: false, description: 'Print only message IDs' }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    limit: Flags.integer({ default: 50, description: 'Maximum messages to print' }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(MessagesIndex)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const cursor = flags.before ?? flags.after
+    const direction = flags.after ? 'after' : flags.before ? 'before' : undefined
+    const useSpinner = !flags.json && !flags.ids
+    const items = useSpinner
+      ? await withSpinner('Loading messages…', () => collectPage(client.messages.list(chatID, { cursor, direction }), flags.limit), {
+        done: value => `${value.length} message${value.length === 1 ? '' : 's'}`,
+      })
+      : await collectPage(client.messages.list(chatID, { cursor, direction }), flags.limit)
+    if (flags.ids) {
+      printIDs(items)
+      return
+    }
+    printList(items, flags.json ? 'json' : 'human', {
+      title: 'No messages yet',
+      subtitle: 'This chat is empty. Send the first message.',
+      suggestions: [
+        { command: `beeper send ${chatID} "<text>"`, hint: 'start the conversation' },
+        { command: `beeper watch ${chatID}`, hint: 'subscribe to events' },
+      ],
+    })
+  }
+}
diff --git a/src/commands/messages/search.ts b/src/commands/messages/search.ts
new file mode 100644
index 0000000..e6465b9
--- /dev/null
+++ b/src/commands/messages/search.ts
@@ -0,0 +1,69 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../../lib/copy.js'
+import { collectPage, printIDs, printList } from '../../lib/output.js'
+import { resolveAccountIDs, resolveChatID } from '../../lib/resolve.js'
+import { withSpinner } from '../../lib/ui.js'
+
+export default class MessagesSearch extends Command {
+  static override summary = apiCopy.messages.search
+  static override args = {
+    query: Args.string({ description: sdkParamCopy.searchQuery, required: false }),
+  }
+  static override flags = {
+    account: Flags.string({ multiple: true, description: `Limit to ${cliCopy.args.accountSelector}` }),
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    chat: Flags.string({ multiple: true, description: `Limit to ${cliCopy.args.chatSelector}` }),
+    'chat-type': Flags.string({ options: ['group', 'single'], description: 'Limit to group chats or direct messages' }),
+    'date-after': Flags.string({ description: 'Only messages after this ISO timestamp' }),
+    'date-before': Flags.string({ description: 'Only messages before this ISO timestamp' }),
+    debug: Flags.boolean({ default: false }),
+    'exclude-low-priority': Flags.boolean({ allowNo: true, description: 'Exclude low-priority chats. Use --no-exclude-low-priority to include all.' }),
+    ids: Flags.boolean({ default: false, description: 'Print only message IDs' }),
+    'include-muted': Flags.boolean({ allowNo: true, description: 'Include muted chats. Use --no-include-muted for a tighter search.' }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    limit: Flags.integer({ default: 50, description: 'Maximum messages to print' }),
+    media: Flags.string({ multiple: true, options: ['any', 'video', 'image', 'link', 'file'], description: 'Filter by media type. Repeat for more types.' }),
+    sender: Flags.string({ description: 'me, others, or a user ID' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(MessagesSearch)
+    const client = await createClient(flags)
+    const accountIDs = await resolveAccountIDs(client, flags.account, { allowMultiplePerInput: true })
+    const chatIDs = flags.chat?.length
+      ? await Promise.all(flags.chat.map(chat => resolveChatID(client, chat, { accountIDs })))
+      : undefined
+    const params = {
+      accountIDs,
+      chatIDs,
+      chatType: flags['chat-type'] as 'group' | 'single' | undefined,
+      dateAfter: flags['date-after'],
+      dateBefore: flags['date-before'],
+      excludeLowPriority: flags['exclude-low-priority'],
+      includeMuted: flags['include-muted'],
+      mediaTypes: flags.media as Array<'any' | 'video' | 'image' | 'link' | 'file'> | undefined,
+      query: args.query,
+      sender: flags.sender as 'me' | 'others' | (string & {}) | undefined,
+    }
+    const useSpinner = !flags.json && !flags.ids
+    const label = args.query ? `Searching messages for "${args.query}"…` : 'Searching messages…'
+    const items = useSpinner
+      ? await withSpinner(label, () => collectPage(client.messages.search(params), flags.limit), {
+        done: value => `${value.length} match${value.length === 1 ? '' : 'es'}`,
+      })
+      : await collectPage(client.messages.search(params), flags.limit)
+    if (flags.ids) {
+      printIDs(items)
+      return
+    }
+    printList(items, flags.json ? 'json' : 'human', {
+      title: 'No messages matched',
+      subtitle: args.query ? `Nothing found for "${args.query}".` : 'Try a different filter combination.',
+      suggestions: [
+        { command: 'beeper messages <chatID>', hint: 'list messages from a chat' },
+        { command: 'beeper search "<term>"', hint: 'search chats + messages' },
+      ],
+    })
+  }
+}
diff --git a/src/commands/mute.ts b/src/commands/mute.ts
new file mode 100644
index 0000000..cec4b5c
--- /dev/null
+++ b/src/commands/mute.ts
@@ -0,0 +1,25 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Mute extends Command {
+  static override summary = 'Mute a chat'
+  static override args = {
+    chat: Args.string({ description: 'Chat ID, local chat ID, title, or search text', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+    pick: Flags.integer({ description: 'Pick the Nth chat when the input is ambiguous' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Mute)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const result = await client.chats.update(chatID, { isMuted: true })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/notify-anyway.ts b/src/commands/notify-anyway.ts
new file mode 100644
index 0000000..09c4989
--- /dev/null
+++ b/src/commands/notify-anyway.ts
@@ -0,0 +1,26 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class NotifyAnyway extends Command {
+  static override summary = apiCopy.chats.notifyAnyway
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(NotifyAnyway)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const result = await client.chats.notifyAnyway(chatID)
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/pin.ts b/src/commands/pin.ts
new file mode 100644
index 0000000..5aaf5a9
--- /dev/null
+++ b/src/commands/pin.ts
@@ -0,0 +1,26 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Pin extends Command {
+  static override summary = 'Pin a chat'
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Pin)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await printData(await client.chats.update(chatID, { isPinned: true }), flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/react.ts b/src/commands/react.ts
new file mode 100644
index 0000000..16709a6
--- /dev/null
+++ b/src/commands/react.ts
@@ -0,0 +1,33 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class React extends Command {
+  static override summary = apiCopy.reactions.add
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    message: Args.string({ description: sdkParamCopy.messageID, required: true }),
+    reaction: Args.string({ description: sdkParamCopy.reactionKey, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+    transaction: Flags.string({ description: 'Optional transaction ID' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(React)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const result = await client.chats.messages.reactions.add(args.message, {
+      chatID,
+      reactionKey: args.reaction,
+      transactionID: flags.transaction,
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/read.ts b/src/commands/read.ts
new file mode 100644
index 0000000..1baad4a
--- /dev/null
+++ b/src/commands/read.ts
@@ -0,0 +1,27 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Read extends Command {
+  static override summary = apiCopy.chats.markRead
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    message: Flags.string({ description: sdkParamCopy.messageID }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Read)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const result = await client.chats.markRead(chatID, { messageID: flags.message })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/remind.ts b/src/commands/remind.ts
new file mode 100644
index 0000000..8519115
--- /dev/null
+++ b/src/commands/remind.ts
@@ -0,0 +1,37 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printSuccess } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Remind extends Command {
+  static override summary = apiCopy.reminders.create
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    when: Args.string({ description: sdkParamCopy.remindAt, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    'dismiss-on-message': Flags.boolean({ default: false, description: 'Cancel if someone messages in the chat' }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Remind)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await client.chats.reminders.create(chatID, {
+      reminder: {
+        dismissOnIncomingMessage: flags['dismiss-on-message'] || undefined,
+        remindAt: args.when,
+      },
+    })
+    await printSuccess({
+      message: 'Reminder set',
+      detail: args.when,
+      data: { chatID, remindAt: args.when, dismissOnIncomingMessage: flags['dismiss-on-message'] },
+    }, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/reply-file.ts b/src/commands/reply-file.ts
new file mode 100644
index 0000000..86c261d
--- /dev/null
+++ b/src/commands/reply-file.ts
@@ -0,0 +1,61 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createReadStream } from 'node:fs'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+import { waitForMessage } from '../lib/wait.js'
+
+export default class ReplyFile extends Command {
+  static override summary = apiCopy.messages.send
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    message: Args.string({ description: sdkParamCopy.replyToMessageID, required: true }),
+    file: Args.string({ description: sdkParamCopy.attachmentFile, required: true }),
+    text: Args.string({ description: sdkParamCopy.text, required: false }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    'file-name': Flags.string({ description: sdkParamCopy.fileName }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    'mime-type': Flags.string({ description: sdkParamCopy.mimeType }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+    wait: Flags.boolean({ default: false, description: 'Wait for the pending message to resolve' }),
+    'wait-interval': Flags.integer({ default: 750, description: 'Milliseconds between message status checks' }),
+    'wait-timeout': Flags.integer({ default: 30000, description: 'Milliseconds to wait for message resolution' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(ReplyFile)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const attachment = await client.assets.upload({
+      file: createReadStream(args.file),
+      fileName: flags['file-name'],
+      mimeType: flags['mime-type'],
+    })
+    if (!attachment.uploadID) throw new Error('Upload did not return an uploadID')
+    const uploadID = attachment.uploadID
+    const result = await client.messages.send(chatID, {
+      attachment: {
+        uploadID,
+        duration: attachment.duration,
+        fileName: attachment.fileName,
+        mimeType: attachment.mimeType,
+        size: attachment.width && attachment.height ? { height: attachment.height, width: attachment.width } : undefined,
+      },
+      replyToMessageID: args.message,
+      text: args.text || '',
+    })
+    if (flags.wait) {
+      const resolved = await waitForMessage(client, chatID, result.pendingMessageID, {
+        intervalMs: flags['wait-interval'],
+        timeoutMs: flags['wait-timeout'],
+      })
+      await printData(resolved, flags.json ? 'json' : 'human')
+      return
+    }
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/reply.ts b/src/commands/reply.ts
new file mode 100644
index 0000000..24afa29
--- /dev/null
+++ b/src/commands/reply.ts
@@ -0,0 +1,63 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createReadStream } from 'node:fs'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+import { waitForMessage } from '../lib/wait.js'
+
+export default class Reply extends Command {
+  static override summary = apiCopy.messages.send
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    message: Args.string({ description: sdkParamCopy.replyToMessageID, required: true }),
+    text: Args.string({ description: sdkParamCopy.text, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    file: Flags.string({ description: sdkParamCopy.attachmentFile }),
+    'file-name': Flags.string({ description: sdkParamCopy.fileName }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    'mime-type': Flags.string({ description: sdkParamCopy.mimeType }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+    wait: Flags.boolean({ default: false, description: 'Wait for the pending message to resolve' }),
+    'wait-interval': Flags.integer({ default: 750, description: 'Milliseconds between message status checks' }),
+    'wait-timeout': Flags.integer({ default: 30000, description: 'Milliseconds to wait for message resolution' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Reply)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const attachment = flags.file
+      ? await client.assets.upload({
+        file: createReadStream(flags.file),
+        fileName: flags['file-name'],
+        mimeType: flags['mime-type'],
+      })
+      : undefined
+    const result = await client.messages.send(chatID, {
+      attachment: attachment?.uploadID
+        ? {
+          uploadID: attachment.uploadID,
+          duration: attachment.duration,
+          fileName: attachment.fileName,
+          mimeType: attachment.mimeType,
+          size: attachment.width && attachment.height ? { height: attachment.height, width: attachment.width } : undefined,
+        }
+        : undefined,
+      replyToMessageID: args.message,
+      text: args.text,
+    })
+    if (flags.wait) {
+      const resolved = await waitForMessage(client, chatID, result.pendingMessageID, {
+        intervalMs: flags['wait-interval'],
+        timeoutMs: flags['wait-timeout'],
+      })
+      await printData(resolved, flags.json ? 'json' : 'human')
+      return
+    }
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/rpc.ts b/src/commands/rpc.ts
new file mode 100644
index 0000000..be899a5
--- /dev/null
+++ b/src/commands/rpc.ts
@@ -0,0 +1,52 @@
+import { Command } from '@oclif/core'
+import { createInterface } from 'node:readline/promises'
+import { stdin as input } from 'node:process'
+import { splitCommandLine } from '../lib/argv.js'
+import { runCli } from '../lib/runner.js'
+
+type RPCRequest = {
+  args?: string[]
+  argv?: string[]
+  command?: string
+  id?: string | number | null
+}
+
+export default class RPC extends Command {
+  static override summary = 'Run newline-delimited JSON command RPC'
+  static override description = 'Reads JSON lines like {"id":1,"command":"send CHAT hello"} or {"id":1,"args":["status","--json"]}.'
+
+  async run(): Promise<void> {
+    const rl = createInterface({ input })
+
+    for await (const line of rl) {
+      if (!line.trim()) continue
+
+      try {
+        const request = JSON.parse(line) as RPCRequest
+        const args = normalizeArgs(request)
+        if (args[0] === 'rpc' || args[0] === 'shell') throw new Error(`Unsupported nested command: ${args[0]}`)
+        const result = await runCli(args)
+        process.stdout.write(`${JSON.stringify({
+          id: request.id ?? null,
+          ok: result.code === 0,
+          code: result.code,
+          signal: result.signal,
+          stdout: result.stdout,
+          stderr: result.stderr,
+        })}\n`)
+      } catch (error) {
+        process.stdout.write(`${JSON.stringify({
+          id: null,
+          ok: false,
+          error: error instanceof Error ? error.message : String(error),
+        })}\n`)
+      }
+    }
+  }
+}
+
+function normalizeArgs(request: RPCRequest): string[] {
+  const args = request.args ?? request.argv ?? (request.command ? splitCommandLine(request.command) : undefined)
+  if (!args || args.length === 0) throw new Error('Expected args, argv, or command')
+  return args
+}
diff --git a/src/commands/search.ts b/src/commands/search.ts
new file mode 100644
index 0000000..6592151
--- /dev/null
+++ b/src/commands/search.ts
@@ -0,0 +1,32 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { printData } from '../lib/output.js'
+import { withSpinner } from '../lib/ui.js'
+
+export default class Search extends Command {
+  static override summary = 'Search chats and messages'
+  static override args = {
+    query: Args.string({ description: 'Literal search query', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Search)
+    const client = await createClient(flags)
+    const result = flags.json
+      ? await client.search({ query: args.query })
+      : await withSpinner(`Searching for "${args.query}"…`, () => client.search({ query: args.query }), {
+        done: value => {
+          const r = value as { chats?: unknown[]; messages?: unknown[] }
+          const chats = r.chats?.length ?? 0
+          const messages = r.messages?.length ?? 0
+          return `${chats} chat${chats === 1 ? '' : 's'}, ${messages} message${messages === 1 ? '' : 's'}`
+        },
+      })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/send-file.ts b/src/commands/send-file.ts
new file mode 100644
index 0000000..4abc389
--- /dev/null
+++ b/src/commands/send-file.ts
@@ -0,0 +1,61 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createReadStream } from 'node:fs'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+import { waitForMessage } from '../lib/wait.js'
+
+export default class SendFile extends Command {
+  static override summary = apiCopy.messages.send
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    file: Args.string({ description: sdkParamCopy.attachmentFile, required: true }),
+    text: Args.string({ description: sdkParamCopy.text, required: false }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    'file-name': Flags.string({ description: sdkParamCopy.fileName }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    'mime-type': Flags.string({ description: sdkParamCopy.mimeType }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+    'reply-to': Flags.string({ description: sdkParamCopy.replyToMessageID }),
+    wait: Flags.boolean({ default: false, description: 'Wait for the pending message to resolve' }),
+    'wait-interval': Flags.integer({ default: 750, description: 'Milliseconds between message status checks' }),
+    'wait-timeout': Flags.integer({ default: 30000, description: 'Milliseconds to wait for message resolution' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(SendFile)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const attachment = await client.assets.upload({
+      file: createReadStream(args.file),
+      fileName: flags['file-name'],
+      mimeType: flags['mime-type'],
+    })
+    if (!attachment.uploadID) throw new Error('Upload did not return an uploadID')
+    const uploadID = attachment.uploadID
+    const result = await client.messages.send(chatID, {
+      attachment: {
+        uploadID,
+        duration: attachment.duration,
+        fileName: attachment.fileName,
+        mimeType: attachment.mimeType,
+        size: attachment.width && attachment.height ? { height: attachment.height, width: attachment.width } : undefined,
+      },
+      replyToMessageID: flags['reply-to'],
+      text: args.text || '',
+    })
+    if (flags.wait) {
+      const resolved = await waitForMessage(client, chatID, result.pendingMessageID, {
+        intervalMs: flags['wait-interval'],
+        timeoutMs: flags['wait-timeout'],
+      })
+      await printData(resolved, flags.json ? 'json' : 'human')
+      return
+    }
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/send.ts b/src/commands/send.ts
new file mode 100644
index 0000000..538790d
--- /dev/null
+++ b/src/commands/send.ts
@@ -0,0 +1,63 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createReadStream } from 'node:fs'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+import { waitForMessage } from '../lib/wait.js'
+
+export default class Send extends Command {
+  static override summary = apiCopy.messages.send
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    text: Args.string({ description: sdkParamCopy.text, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    file: Flags.string({ description: sdkParamCopy.attachmentFile }),
+    'file-name': Flags.string({ description: sdkParamCopy.fileName }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    'mime-type': Flags.string({ description: sdkParamCopy.mimeType }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+    'reply-to': Flags.string({ description: sdkParamCopy.replyToMessageID }),
+    wait: Flags.boolean({ default: false, description: 'Wait for the pending message to resolve' }),
+    'wait-interval': Flags.integer({ default: 750, description: 'Milliseconds between message status checks' }),
+    'wait-timeout': Flags.integer({ default: 30000, description: 'Milliseconds to wait for message resolution' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Send)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const attachment = flags.file
+      ? await client.assets.upload({
+        file: createReadStream(flags.file),
+        fileName: flags['file-name'],
+        mimeType: flags['mime-type'],
+      })
+      : undefined
+    const result = await client.messages.send(chatID, {
+      attachment: attachment?.uploadID
+        ? {
+          uploadID: attachment.uploadID,
+          duration: attachment.duration,
+          fileName: attachment.fileName,
+          mimeType: attachment.mimeType,
+          size: attachment.width && attachment.height ? { height: attachment.height, width: attachment.width } : undefined,
+        }
+        : undefined,
+      replyToMessageID: flags['reply-to'],
+      text: args.text,
+    })
+    if (flags.wait) {
+      const resolved = await waitForMessage(client, chatID, result.pendingMessageID, {
+        intervalMs: flags['wait-interval'],
+        timeoutMs: flags['wait-timeout'],
+      })
+      await printData(resolved, flags.json ? 'json' : 'human')
+      return
+    }
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/shell.ts b/src/commands/shell.ts
new file mode 100644
index 0000000..7238092
--- /dev/null
+++ b/src/commands/shell.ts
@@ -0,0 +1,40 @@
+import { Command } from '@oclif/core'
+import { createInterface } from 'node:readline/promises'
+import { stdin as input, stdout as output } from 'node:process'
+import { splitCommandLine } from '../lib/argv.js'
+import { runCli } from '../lib/runner.js'
+
+export default class Shell extends Command {
+  static override summary = 'Run an interactive Beeper CLI shell'
+
+  async run(): Promise<void> {
+    const rl = createInterface({ input, output, prompt: 'beeper> ' })
+    let closed = false
+    rl.on('close', () => {
+      closed = true
+    })
+    const interactive = Boolean(input.isTTY && output.isTTY)
+    if (interactive) rl.prompt()
+
+    for await (const line of rl) {
+      const trimmed = line.trim()
+      if (!trimmed) {
+        if (interactive && !closed) rl.prompt()
+        continue
+      }
+      if (trimmed === 'exit' || trimmed === 'quit') break
+
+      try {
+        const args = splitCommandLine(trimmed)
+        if (args[0] === 'shell') throw new Error('Nested shell is not supported')
+        await runCli(args, { inherit: true })
+      } catch (error) {
+        this.error(error instanceof Error ? error.message : String(error), { exit: false })
+      }
+
+      if (interactive && !closed) rl.prompt()
+    }
+
+    if (!closed) rl.close()
+  }
+}
diff --git a/src/commands/start-chat.ts b/src/commands/start-chat.ts
new file mode 100644
index 0000000..026f7f4
--- /dev/null
+++ b/src/commands/start-chat.ts
@@ -0,0 +1,56 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { listAccountIDs, resolveAccountIDs, userQueryFromInput } from '../lib/resolve.js'
+
+export default class StartChat extends Command {
+  static override summary = apiCopy.chats.start
+  static override args = {
+    query: Args.string({ description: 'Phone, email, username, user ID, or name', required: false }),
+  }
+  static override flags = {
+    account: Flags.string({ multiple: true, description: `${cliCopy.args.accountSelector}. Omit to try every account.` }),
+    'allow-invite': Flags.boolean({ default: false, description: 'Allow invite-based DM creation when required' }),
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    email: Flags.string({ description: 'Email address' }),
+    id: Flags.string({ description: 'Known user ID' }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    message: Flags.string({ description: 'Optional first message' }),
+    name: Flags.string({ description: 'Display name hint' }),
+    phone: Flags.string({ description: 'Phone number' }),
+    username: Flags.string({ description: 'Username' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(StartChat)
+    const client = await createClient(flags)
+    const accountIDs = await resolveAccountIDs(client, flags.account, { allowMultiplePerInput: true }) ?? await listAccountIDs(client)
+    const user: Record<string, string> = args.query ? userQueryFromInput(args.query) : {}
+    if (flags.email) user.email = flags.email
+    if (flags.name) user.fullName = flags.name
+    if (flags.id) user.id = flags.id
+    if (flags.phone) user.phoneNumber = flags.phone
+    if (flags.username) user.username = flags.username
+    const result = await tryStartChat(client, accountIDs, {
+      allowInvite: flags['allow-invite'] || undefined,
+      messageText: flags.message,
+      user,
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
+
+async function tryStartChat(client: any, accountIDs: string[], body: Record<string, unknown>) {
+  const failures: string[] = []
+  for (const accountID of accountIDs) {
+    try {
+      return await client.chats.start({ ...body, accountID })
+    } catch (error) {
+      failures.push(`${accountID}: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  throw new Error(`No account could start this chat:\n${failures.map(failure => `  - ${failure}`).join('\n')}`)
+}
diff --git a/src/commands/status.ts b/src/commands/status.ts
new file mode 100644
index 0000000..f552633
--- /dev/null
+++ b/src/commands/status.ts
@@ -0,0 +1,30 @@
+import { Command, Flags } from '@oclif/core'
+import { readConfig } from '../lib/config.js'
+import { printData } from '../lib/output.js'
+import { withSpinner } from '../lib/ui.js'
+
+export default class Status extends Command {
+  static override summary = 'Check Beeper Desktop API status'
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(Status)
+    const config = await readConfig()
+    const baseURL = flags['base-url'] ?? config.baseURL
+    const fetchInfo = async (): Promise<unknown> => {
+      const response = await fetch(new URL('/v1/info', baseURL))
+      if (!response.ok) throw new Error(`Beeper Desktop API returned ${response.status} ${response.statusText}`)
+      return response.json()
+    }
+    const info = flags.json
+      ? await fetchInfo()
+      : await withSpinner(`Pinging Beeper Desktop at ${baseURL}…`, fetchInfo, {
+        done: value => `Beeper Desktop v${(value as { version?: string }).version ?? '?'} reachable`,
+      })
+    await printData(info, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/tail.ts b/src/commands/tail.ts
new file mode 100644
index 0000000..7218830
--- /dev/null
+++ b/src/commands/tail.ts
@@ -0,0 +1 @@
+export { default } from './watch.js'
diff --git a/src/commands/thread.ts b/src/commands/thread.ts
new file mode 100644
index 0000000..691c701
--- /dev/null
+++ b/src/commands/thread.ts
@@ -0,0 +1 @@
+export { default } from './chat.js'
diff --git a/src/commands/threads.ts b/src/commands/threads.ts
new file mode 100644
index 0000000..0d76408
--- /dev/null
+++ b/src/commands/threads.ts
@@ -0,0 +1 @@
+export { default } from './chats/index.js'
diff --git a/src/commands/title.ts b/src/commands/title.ts
new file mode 100644
index 0000000..f9724f0
--- /dev/null
+++ b/src/commands/title.ts
@@ -0,0 +1,27 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Title extends Command {
+  static override summary = 'Set a custom chat title'
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    title: Args.string({ description: 'New chat title', required: true }),
+  }
+
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Title)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await printData(await client.chats.update(chatID, { title: args.title }), flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/unarchive.ts b/src/commands/unarchive.ts
new file mode 100644
index 0000000..6f1c625
--- /dev/null
+++ b/src/commands/unarchive.ts
@@ -0,0 +1,26 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy } from '../lib/copy.js'
+import { printSuccess } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Unarchive extends Command {
+  static override summary = apiCopy.chats.archive
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Unarchive)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await client.chats.archive(chatID, { archived: false })
+    await printSuccess({ message: 'Unarchived', detail: chatID, data: { chatID } }, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/unmute.ts b/src/commands/unmute.ts
new file mode 100644
index 0000000..f4bfaed
--- /dev/null
+++ b/src/commands/unmute.ts
@@ -0,0 +1,25 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Unmute extends Command {
+  static override summary = 'Unmute a chat'
+  static override args = {
+    chat: Args.string({ description: 'Chat ID, local chat ID, title, or search text', required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: 'Print JSON' }),
+    pick: Flags.integer({ description: 'Pick the Nth chat when the input is ambiguous' }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Unmute)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const result = await client.chats.update(chatID, { isMuted: false })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/unpin.ts b/src/commands/unpin.ts
new file mode 100644
index 0000000..bc3a594
--- /dev/null
+++ b/src/commands/unpin.ts
@@ -0,0 +1,26 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { cliCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Unpin extends Command {
+  static override summary = 'Unpin a chat'
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Unpin)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await printData(await client.chats.update(chatID, { isPinned: false }), flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/unreact.ts b/src/commands/unreact.ts
new file mode 100644
index 0000000..e4f5cf5
--- /dev/null
+++ b/src/commands/unreact.ts
@@ -0,0 +1,31 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Unreact extends Command {
+  static override summary = apiCopy.reactions.delete
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+    message: Args.string({ description: sdkParamCopy.messageID, required: true }),
+    reaction: Args.string({ description: sdkParamCopy.reactionKey, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Unreact)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const result = await client.chats.messages.reactions.delete(args.reaction, {
+      chatID,
+      messageID: args.message,
+    })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/unread.ts b/src/commands/unread.ts
new file mode 100644
index 0000000..a94525a
--- /dev/null
+++ b/src/commands/unread.ts
@@ -0,0 +1,27 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy, sdkParamCopy } from '../lib/copy.js'
+import { printData } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Unread extends Command {
+  static override summary = apiCopy.chats.markUnread
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    message: Flags.string({ description: sdkParamCopy.messageID }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Unread)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    const result = await client.chats.markUnread(chatID, { messageID: flags.message })
+    await printData(result, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/unremind.ts b/src/commands/unremind.ts
new file mode 100644
index 0000000..e37b7e1
--- /dev/null
+++ b/src/commands/unremind.ts
@@ -0,0 +1,26 @@
+import { Args, Command, Flags } from '@oclif/core'
+import { createClient } from '../lib/client.js'
+import { apiCopy, cliCopy } from '../lib/copy.js'
+import { printSuccess } from '../lib/output.js'
+import { resolveChatID } from '../lib/resolve.js'
+
+export default class Unremind extends Command {
+  static override summary = apiCopy.reminders.delete
+  static override args = {
+    chat: Args.string({ description: cliCopy.args.chatSelector, required: true }),
+  }
+  static override flags = {
+    'base-url': Flags.string({ description: cliCopy.flags.baseURL }),
+    debug: Flags.boolean({ default: false }),
+    json: Flags.boolean({ default: false, description: cliCopy.flags.json }),
+    pick: Flags.integer({ description: cliCopy.flags.pick }),
+  }
+
+  async run(): Promise<void> {
+    const { args, flags } = await this.parse(Unremind)
+    const client = await createClient(flags)
+    const chatID = await resolveChatID(client, args.chat, { pick: flags.pick })
+    await client.chats.reminders.delete(chatID)
+    await printSuccess({ message: 'Reminder cleared', detail: chatID, data: { chatID } }, flags.json ? 'json' : 'human')
+  }
+}
diff --git a/src/commands/watch.ts b/src/commands/watch.ts
new file mode 100644
index 0000000..59a0636
--- /dev/null
+++ b/src/commands/watch.ts
@@ -0,0 +1,93 @@
+import { Command, Flags } from '@oclif/core'
+import { requireToken } from '../lib/client.js'
+import { getBaseURL } from '../lib/config.js'
+import { startStream } from '../lib/output.js'
+
+export default class Watch extends Command {
+  static override summary = 'Stream Desktop API WebSocket events'
+  static override flags = {
+    'base-url': Flags.string({ description: 'Beeper Desktop API base URL' }),
+    chat: Flags.string({ char: 'c', multiple: true, description: 'Chat ID to subscribe to. Defaults to all chats.' }),
+    json: Flags.boolean({ default: false, description: 'Print raw JSON, one event per line' }),
+  }
+
+  async run(): Promise<void> {
+    const { flags } = await this.parse(Watch)
+    const token = await requireToken()
+    const baseURL = await getBaseURL(flags['base-url'])
+    const info = await fetch(new URL('/v1/info', baseURL))
+    if (!info.ok) throw new Error(`Failed to fetch /v1/info: HTTP ${info.status}`)
+    const metadata = await info.json() as { endpoints?: { ws_events?: string } }
+    const endpoint = metadata.endpoints?.ws_events || '/v1/ws'
+    const url = new URL(endpoint, baseURL)
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:'
+
+    const subscribed = flags.chat?.length ? flags.chat : ['*']
+    const ws = new WebSocket(url, { headers: { Authorization: `Bearer ${token}` } } as unknown as string[])
+
+    if (flags.json) {
+      await this.runJSON(ws, subscribed)
+      return
+    }
+    await this.runHuman(ws, subscribed, baseURL)
+  }
+
+  private async runJSON(ws: WebSocket, subscribed: string[]): Promise<void> {
+    ws.addEventListener('open', () => ws.send(JSON.stringify({ type: 'subscriptions.set', chatIDs: subscribed })))
+    ws.addEventListener('message', event => {
+      const data = typeof event.data === 'string' ? event.data : event.data.toString()
+      process.stdout.write(`${data}\n`)
+    })
+    ws.addEventListener('error', () => this.error('WebSocket connection failed', { exit: 1 }))
+    ws.addEventListener('close', event => {
+      if (event.code !== 1000) this.error(`WebSocket closed: ${event.code} ${event.reason}`, { exit: 1 })
+    })
+    await new Promise<void>(resolve => {
+      process.once('SIGINT', () => { ws.close(1000); resolve() })
+      ws.addEventListener('close', () => resolve())
+    })
+  }
+
+  private async runHuman(ws: WebSocket, subscribed: string[], baseURL: string): Promise<void> {
+    const stream = await startStream({ baseURL, subscribed })
+    let closed = false
+
+    const finish = async (): Promise<void> => {
+      if (closed) return
+      closed = true
+      try { ws.close(1000) } catch { /* ignore */ }
+      await stream.close()
+    }
+
+    ws.addEventListener('open', () => {
+      stream.setConnected(true)
+      ws.send(JSON.stringify({ type: 'subscriptions.set', chatIDs: subscribed }))
+    })
+    ws.addEventListener('message', event => {
+      const data = typeof event.data === 'string' ? event.data : event.data.toString()
+      try {
+        const parsed = JSON.parse(data) as Record<string, unknown>
+        stream.push({
+          type: typeof parsed.type === 'string' ? parsed.type : 'event',
+          chatID: typeof parsed.chatID === 'string' ? parsed.chatID : undefined,
+          messageID: typeof parsed.messageID === 'string' ? parsed.messageID : undefined,
+          ts: typeof parsed.timestamp === 'string' ? parsed.timestamp : new Date().toISOString(),
+        })
+      } catch {
+        stream.push({ type: 'raw', ts: new Date().toISOString() })
+      }
+    })
+    ws.addEventListener('error', () => {
+      stream.setConnected(false)
+      stream.setStatus('connection error')
+    })
+    ws.addEventListener('close', event => {
+      stream.setConnected(false)
+      if (event.code !== 1000) stream.setStatus(`closed ${event.code}${event.reason ? ` ${event.reason}` : ''}`)
+      void finish()
+    })
+    process.once('SIGINT', () => { void finish() })
+
+    await stream.done
+  }
+}
diff --git a/src/commands/whoami.ts b/src/commands/whoami.ts
new file mode 100644
index 0000000..f7962f8
--- /dev/null
+++ b/src/commands/whoami.ts
@@ -0,0 +1 @@
+export { default } from './current-user.js'
diff --git a/src/lib/account-login.ts b/src/lib/account-login.ts
new file mode 100644
index 0000000..5135420
--- /dev/null
+++ b/src/lib/account-login.ts
@@ -0,0 +1,127 @@
+import { createInterface } from 'node:readline/promises'
+import { stdin as input, stdout as output } from 'node:process'
+import type {
+  AuthStartLoginResponse,
+  AuthSubmitCookiesResponse,
+  AuthSubmitUserInputResponse,
+  AuthWaitForStepResponse,
+} from '@beeper/desktop-api/resources/matrix/bridges/auth.js'
+import type BeeperDesktop from '@beeper/desktop-api'
+
+export type AccountLoginStep =
+  | AuthStartLoginResponse
+  | AuthSubmitCookiesResponse
+  | AuthSubmitUserInputResponse
+  | AuthWaitForStepResponse
+
+export type AccountLoginOptions = {
+  cookies?: Record<string, string>
+  fields?: Record<string, string>
+  nonInteractive?: boolean
+}
+
+type CommonStep = {
+  instructions?: string
+  login_id?: string
+  step_id?: string
+  type: string
+}
+
+export function printAccountLoginStep(step: AccountLoginStep): void {
+  const common = step as CommonStep
+  process.stdout.write(`step: ${common.type}\n`)
+  if (common.instructions) process.stdout.write(`${common.instructions}\n`)
+  if (common.login_id) process.stdout.write(`login_id: ${common.login_id}\n`)
+  if (common.step_id) process.stdout.write(`step_id: ${common.step_id}\n`)
+
+  if ('display_and_wait' in step) {
+    const display = step.display_and_wait
+    process.stdout.write(`display: ${display.type}\n`)
+    if (display.data) process.stdout.write(`${display.data}\n`)
+    if (display.image_url) process.stdout.write(`image: ${display.image_url}\n`)
+  } else if ('user_input' in step) {
+    for (const field of step.user_input.fields) {
+      const details = [field.type, field.description, field.options?.length ? `options: ${field.options.join(', ')}` : undefined]
+        .filter(Boolean)
+        .join(' | ')
+      process.stdout.write(`field ${field.id}: ${field.name}${details ? ` (${details})` : ''}\n`)
+    }
+  } else if ('cookies' in step) {
+    process.stdout.write(`url: ${step.cookies.url}\n`)
+    if (step.cookies.user_agent) process.stdout.write(`user_agent: ${step.cookies.user_agent}\n`)
+    if (step.cookies.wait_for_url_pattern) process.stdout.write(`wait_for_url_pattern: ${step.cookies.wait_for_url_pattern}\n`)
+    for (const field of step.cookies.fields) process.stdout.write(`cookie field ${field.name}: ${field.type}\n`)
+    if (step.cookies.extract_js) process.stdout.write(`extract_js:\n${step.cookies.extract_js}\n`)
+  } else if ('complete' in step) {
+    process.stdout.write(`complete: ${step.complete.user_login_id ?? 'yes'}\n`)
+  }
+}
+
+export async function runGuidedAccountLogin(client: BeeperDesktop, bridgeID: string, initialStep: AccountLoginStep, options: AccountLoginOptions = {}): Promise<AccountLoginStep> {
+  let step = initialStep
+  for (;;) {
+    printAccountLoginStep(step)
+    if ('complete' in step) return step
+
+    const loginProcessID = (step as CommonStep).login_id
+    const stepID = (step as CommonStep).step_id
+    if (!loginProcessID || !stepID) throw new Error('Account login step did not include login_id and step_id.')
+
+    if ('display_and_wait' in step) {
+      await promptText('Press Enter after completing this step.')
+      step = await client.matrix.bridges.auth.waitForStep(stepID, { bridgeID, loginProcessID })
+      continue
+    }
+
+    if ('user_input' in step) {
+      const body: Record<string, string> = {}
+      for (const field of step.user_input.fields) {
+        if (options.fields?.[field.id] !== undefined) {
+          body[field.id] = options.fields[field.id]!
+          continue
+        }
+
+        if (options.nonInteractive) {
+          if (field.default_value !== undefined) {
+            body[field.id] = field.default_value
+            continue
+          }
+
+          throw new Error(`Missing required field ${field.id}. Pass --field ${field.id}=... or run without --non-interactive.`)
+        }
+
+        const fallback = field.default_value ? ` [${field.default_value}]` : ''
+        const value = await promptText(`${field.name}${fallback}: `)
+        body[field.id] = value || field.default_value || ''
+      }
+      step = await client.matrix.bridges.auth.submitUserInput(stepID, { bridgeID, loginProcessID, body })
+      continue
+    }
+
+    if ('cookies' in step) {
+      const body: Record<string, string> = {}
+      for (const field of step.cookies.fields) {
+        if (options.cookies?.[field.name] !== undefined) {
+          body[field.name] = options.cookies[field.name]!
+          continue
+        }
+
+        if (options.nonInteractive) throw new Error(`Missing required cookie ${field.name}. Pass --cookie ${field.name}=... or run without --non-interactive.`)
+        body[field.name] = await promptText(`${field.name}: `)
+      }
+      step = await client.matrix.bridges.auth.submitCookies(stepID, { bridgeID, loginProcessID, body })
+      continue
+    }
+
+    throw new Error(`Unsupported account login step: ${(step as CommonStep).type}`)
+  }
+}
+
+async function promptText(label: string): Promise<string> {
+  const rl = createInterface({ input, output })
+  try {
+    return (await rl.question(label)).trim()
+  } finally {
+    rl.close()
+  }
+}
diff --git a/src/lib/app-api.ts b/src/lib/app-api.ts
new file mode 100644
index 0000000..b5093db
--- /dev/null
+++ b/src/lib/app-api.ts
@@ -0,0 +1,62 @@
+import { createInterface } from 'node:readline/promises'
+import { stdin as input, stdout as output } from 'node:process'
+import { getAccessToken, readConfig } from './config.js'
+import type { AppStatusResponse } from '@beeper/desktop-api/resources/app/app.js'
+import type {
+  LoginRegisterResponse,
+  LoginResponseResponse,
+} from '@beeper/desktop-api/resources/app/login.js'
+import type { ResetBeginResponse } from '@beeper/desktop-api/resources/app/e2ee/recovery-code/reset.js'
+
+export type AppStateSnapshot = AppStatusResponse
+export type AppLoginSuccess = LoginRegisterResponse
+export type AppRegistrationRequired = Extract<LoginResponseResponse, { registrationRequired: true }>
+export type AppLoginOutput = LoginResponseResponse
+
+export type AppMutationResponse = {
+  appState: AppStateSnapshot
+}
+
+export type AppRecoveryCodeResetBeginResponse = ResetBeginResponse
+
+export async function appRequest<T>(
+  method: 'GET' | 'POST',
+  path: string,
+  options: { baseURL?: string; body?: Record<string, unknown>; token?: string | false } = {},
+): Promise<T> {
+  const config = await readConfig()
+  const baseURL = options.baseURL ?? config.baseURL
+  const token = options.token === false ? undefined : options.token ?? await getAccessToken()
+  const headers: Record<string, string> = {}
+  if (token) headers.authorization = `Bearer ${token}`
+  if (options.body) headers['content-type'] = 'application/json'
+
+  const response = await fetch(new URL(path, baseURL), {
+    method,
+    headers,
+    body: options.body ? JSON.stringify(options.body) : undefined,
+  })
+  if (!response.ok) throw new Error(`${method} ${path} failed: ${response.status} ${await response.text()}`)
+  if (response.status === 204) return undefined as T
+  const text = await response.text()
+  return (text ? JSON.parse(text) : {}) as T
+}
+
+export async function promptText(label: string): Promise<string> {
+  const rl = createInterface({ input, output })
+  try {
+    const value = await rl.question(label)
+    return value.trim()
+  } finally {
+    rl.close()
+  }
+}
+
+export async function promptYesNo(label: string): Promise<boolean> {
+  const value = (await promptText(`${label} [y/N] `)).toLowerCase()
+  return value === 'y' || value === 'yes'
+}
+
+export function isRegistrationRequired(output: AppLoginOutput): output is AppRegistrationRequired {
+  return 'registrationRequired' in output && output.registrationRequired === true
+}
diff --git a/src/lib/argv.ts b/src/lib/argv.ts
new file mode 100644
index 0000000..aeac915
--- /dev/null
+++ b/src/lib/argv.ts
@@ -0,0 +1,39 @@
+export function splitCommandLine(input: string): string[] {
+  const tokens: string[] = []
+  let current = ''
+  let quote: '"' | "'" | undefined
+  let escaped = false
+
+  for (const char of input) {
+    if (escaped) {
+      current += char
+      escaped = false
+      continue
+    }
+
+    if (char === '\\' && quote !== "'") {
+      escaped = true
+      continue
+    }
+
+    if ((char === '"' || char === "'") && (!quote || quote === char)) {
+      quote = quote ? undefined : char
+      continue
+    }
+
+    if (!quote && /\s/.test(char)) {
+      if (current) {
+        tokens.push(current)
+        current = ''
+      }
+      continue
+    }
+
+    current += char
+  }
+
+  if (escaped) current += '\\'
+  if (quote) throw new Error(`Unclosed ${quote} quote`)
+  if (current) tokens.push(current)
+  return tokens
+}
diff --git a/src/lib/client.ts b/src/lib/client.ts
new file mode 100644
index 0000000..033cd88
--- /dev/null
+++ b/src/lib/client.ts
@@ -0,0 +1,23 @@
+import BeeperDesktop from '@beeper/desktop-api'
+import { readConfig } from './config.js'
+import { ensureDesktopToken } from './desktop-auth.js'
+
+export async function createClient(flags: { baseURL?: string; 'base-url'?: string; debug?: boolean } = {}) {
+  const explicitBaseURL = flags.baseURL || flags['base-url']
+  const config = await readConfig()
+  const accessToken = process.env.BEEPER_ACCESS_TOKEN
+    || config.auth?.accessToken
+    || await ensureDesktopToken({ baseURL: explicitBaseURL, scan: !explicitBaseURL })
+  return new BeeperDesktop({
+    accessToken,
+    baseURL: explicitBaseURL || config.baseURL,
+    logLevel: flags.debug ? 'debug' : 'warn',
+  })
+}
+
+export async function requireToken(options: { baseURL?: string; scan?: boolean } = {}): Promise<string> {
+  const config = await readConfig()
+  const token = process.env.BEEPER_ACCESS_TOKEN || config.auth?.accessToken
+  if (token) return token
+  return ensureDesktopToken({ baseURL: options.baseURL, scan: options.scan })
+}
diff --git a/src/lib/config.ts b/src/lib/config.ts
new file mode 100644
index 0000000..050bf24
--- /dev/null
+++ b/src/lib/config.ts
@@ -0,0 +1,59 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { homedir } from 'node:os'
+
+export type StoredAuth = {
+  accessToken: string
+  clientID?: string
+  expiresAt?: string
+  scope?: string
+  tokenType: 'Bearer'
+}
+
+export type Config = {
+  auth?: StoredAuth
+  baseURL: string
+}
+
+const defaultBaseURL = 'http://127.0.0.1:23373'
+
+export const configPath = () =>
+  join(process.env.BEEPER_CLI_CONFIG_DIR ?? join(homedir(), '.config', 'beeper'), 'config.json')
+
+export async function readConfig(): Promise<Config> {
+  const baseURL = process.env.BEEPER_DESKTOP_BASE_URL || process.env.BEEPER_BASE_URL
+  try {
+    const raw = await readFile(configPath(), 'utf8')
+    const parsed = JSON.parse(raw) as Partial<Config>
+    return {
+      baseURL: baseURL || parsed.baseURL || defaultBaseURL,
+      auth: parsed.auth,
+    }
+  } catch {
+    return { baseURL: baseURL || defaultBaseURL }
+  }
+}
+
+export async function writeConfig(config: Config): Promise<void> {
+  const file = configPath()
+  await mkdir(dirname(file), { recursive: true })
+  await writeFile(file, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 })
+}
+
+export async function updateConfig(update: (config: Config) => Config | Promise<Config>): Promise<Config> {
+  const next = await update(await readConfig())
+  await writeConfig(next)
+  return next
+}
+
+export async function resetConfig(): Promise<void> {
+  await rm(configPath(), { force: true })
+}
+
+export async function getAccessToken(): Promise<string | undefined> {
+  return process.env.BEEPER_ACCESS_TOKEN || (await readConfig()).auth?.accessToken
+}
+
+export async function getBaseURL(override?: string): Promise<string> {
+  return override || (await readConfig()).baseURL
+}
diff --git a/src/lib/copy.ts b/src/lib/copy.ts
new file mode 100644
index 0000000..8a7789d
--- /dev/null
+++ b/src/lib/copy.ts
@@ -0,0 +1,66 @@
+export const apiCopy = {
+  accounts: {
+    list: 'List Chat Accounts connected to this Beeper Desktop instance, including bridge metadata and network identity.',
+  },
+  assets: {
+    download: 'Download a Matrix file using its mxc:// or localmxc:// URL to the device running Beeper Desktop and return the local file URL.',
+    upload: 'Upload a file to a temporary location using multipart/form-data. Returns an uploadID that can be referenced when sending a message or materializing a draft attachment.',
+  },
+  chats: {
+    archive: 'Archive or unarchive a chat. Set archived=true to move to archive, archived=false to move back to inbox',
+    create: 'Create a direct or group chat from participant IDs. Returns the created chat.',
+    list: 'List all chats sorted by last activity (most recent first). Combines all accounts into a single paginated list.',
+    markRead: 'Mark a chat as read, optionally through a specific message ID.',
+    markUnread: 'Mark a chat as unread, optionally from a specific message ID.',
+    notifyAnyway: 'Force a delivery notification when supported by the underlying network. Currently intended for iMessage on macOS; unsupported networks return an error.',
+    retrieve: 'Retrieve chat details including metadata, participants, and latest message',
+    search: 'Search chats by title, network, or participant names.',
+    start: 'Resolve a user/contact and open a direct chat. Reuses and returns an existing direct chat when one is found. Available in Beeper Desktop v4.2.808+.',
+  },
+  contacts: {
+    list: 'List merged contacts for a specific account with cursor-based pagination.',
+    search: 'Search contacts on a specific account using merged account contacts, network search, and exact identifier lookup.',
+  },
+  messages: {
+    delete: 'Delete a message by final message ID. Pending message IDs are not accepted because messages cannot be deleted while sending.',
+    list: 'List all messages in a chat with cursor-based pagination. Sorted by timestamp.',
+    retrieve: 'Retrieve a message by final message ID, pendingMessageID, or Matrix event ID. Chat ID may be a Beeper chat ID or local chat ID.',
+    search: 'Search messages across chats.',
+    send: 'Send a text message to a specific chat. Supports replying to existing messages. Returns a pending message ID.',
+    update: 'Edit the text content of an existing message. Messages with attachments cannot be edited.',
+  },
+  reactions: {
+    add: 'Add a reaction to an existing message.',
+    delete: 'Remove the reaction added by the authenticated user from an existing message.',
+  },
+  reminders: {
+    create: 'Set a reminder for a chat at a specific time',
+    delete: 'Clear an existing reminder from a chat',
+  },
+} as const
+
+export const sdkParamCopy = {
+  attachmentFile: 'The file to upload (max 500 MB).',
+  chatID: 'Chat ID. Input routes also accept the local chat ID from this Beeper Desktop installation when available.',
+  fileName: 'Original filename. Defaults to the uploaded file name if omitted',
+  forEveryone: 'True to request deletion for everyone when the network supports it; false to delete only for the authenticated user when supported.',
+  messageID: 'Message ID.',
+  mimeType: 'MIME type. Auto-detected from magic bytes if omitted',
+  reactionKey: 'Reaction key to add (emoji, shortcode, or custom emoji key)',
+  remindAt: 'Timestamp when the reminder should trigger.',
+  replyToMessageID: 'Provide a message ID to send this as a reply to an existing message',
+  searchQuery: 'User-typed search text. Literal word matching (non-semantic).',
+  text: 'Draft text. Plain text and Markdown are converted to Matrix HTML with the same rules used by send and edit.',
+} as const
+
+export const cliCopy = {
+  args: {
+    accountSelector: 'Account ID, network, bridge, or account user',
+    chatSelector: `${sdkParamCopy.chatID} Also accepts exact chat titles or search text.`,
+  },
+  flags: {
+    baseURL: 'Beeper Desktop API base URL',
+    json: 'Print JSON',
+    pick: 'Pick the Nth chat when the input is ambiguous',
+  },
+} as const
diff --git a/src/lib/desktop-auth.ts b/src/lib/desktop-auth.ts
new file mode 100644
index 0000000..ec7808b
--- /dev/null
+++ b/src/lib/desktop-auth.ts
@@ -0,0 +1,96 @@
+import { readConfig } from './config.js'
+import { loginWithPKCE } from './oauth.js'
+
+export type DesktopAppStatus = {
+  state?: string
+}
+
+type DesktopProbe = {
+  baseURL: string
+  status?: DesktopAppStatus
+}
+
+const defaultPort = 23_373
+const scanPorts = Array.from({ length: 20 }, (_, index) => defaultPort + index)
+
+export async function findLocalDesktop(options: { baseURL?: string; scan?: boolean; timeoutMs?: number } = {}): Promise<DesktopProbe> {
+  const config = await readConfig()
+  const preferred = options.baseURL ?? config.baseURL
+  const candidates = candidateBaseURLs(preferred, options.scan ?? true)
+  const timeoutMs = options.timeoutMs ?? 500
+
+  const preferredProbe = await probeDesktop(preferred, timeoutMs)
+  if (preferredProbe) return preferredProbe
+
+  const rest = candidates.filter(url => url !== preferred)
+  if (rest.length) {
+    try {
+      return await Promise.any(rest.map(async url => {
+        const probe = await probeDesktop(url, timeoutMs)
+        if (!probe) throw new Error('not found')
+        return probe
+      }))
+    } catch { /* fall through */ }
+  }
+
+  throw new Error(`Could not find a running Beeper Desktop API on ${candidates.join(', ')}.`)
+}
+
+export async function ensureDesktopToken(options: {
+  baseURL?: string
+  clientName?: string
+  openBrowser?: boolean
+  scan?: boolean
+  scope?: string
+} = {}): Promise<string> {
+  const desktop = await findLocalDesktop({ baseURL: options.baseURL, scan: options.scan })
+  if (desktop.status?.state === 'needs-login') {
+    throw new Error('Beeper Desktop is not signed in. Open Beeper Desktop and sign in, then rerun this command.')
+  }
+
+  const token = await loginWithPKCE({
+    baseURL: desktop.baseURL,
+    clientName: options.clientName ?? 'Beeper CLI',
+    openBrowser: options.openBrowser ?? true,
+    save: true,
+    scope: options.scope ?? 'read write',
+  })
+  return token.access_token
+}
+
+export async function getDesktopAppStatus(baseURL: string): Promise<DesktopAppStatus | undefined> {
+  const response = await fetchWithTimeout(new URL('/v1/app/status', baseURL), {}, 2_000)
+  if (response.status === 401 || response.status === 403 || response.status === 404) return undefined
+  if (!response.ok) throw new Error(`GET /v1/app/status failed: ${response.status} ${await response.text()}`)
+  return response.json() as Promise<DesktopAppStatus>
+}
+
+function candidateBaseURLs(preferred: string, scan: boolean): string[] {
+  const urls = new Set<string>([preferred])
+  if (!scan) return [...urls]
+  for (const port of scanPorts) {
+    urls.add(`http://127.0.0.1:${port}`)
+    urls.add(`http://localhost:${port}`)
+  }
+  return [...urls]
+}
+
+async function probeDesktop(baseURL: string, timeoutMs: number): Promise<DesktopProbe | undefined> {
+  try {
+    const info = await fetchWithTimeout(new URL('/v1/info', baseURL), {}, timeoutMs)
+    if (!info.ok) return undefined
+    return { baseURL, status: await getDesktopAppStatus(baseURL) }
+  } catch {
+    return undefined
+  }
+}
+
+async function fetchWithTimeout(url: URL, init: RequestInit = {}, timeoutMs: number): Promise<Response> {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), timeoutMs)
+  try {
+    return await fetch(url, { ...init, signal: controller.signal })
+  } finally {
+    clearTimeout(timeout)
+  }
+}
diff --git a/src/lib/export/index.ts b/src/lib/export/index.ts
new file mode 100644
index 0000000..598aa62
--- /dev/null
+++ b/src/lib/export/index.ts
@@ -0,0 +1,547 @@
+import { createWriteStream } from 'node:fs'
+import type { FileHandle } from 'node:fs/promises'
+import { copyFile, mkdir, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises'
+import { basename, dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { Chat } from '@beeper/desktop-api/resources/chats/chats'
+import type { Attachment, Message } from '@beeper/desktop-api/resources/shared'
+
+type AnyRecord = Record<string, any>
+
+export type ExportOptions = {
+  accountIDs?: string[]
+  chatIDs?: string[]
+  downloadAttachments: boolean
+  force: boolean
+  limitChats?: number
+  limitMessages?: number
+  maxParticipants?: number
+  outDir: string
+  quiet: boolean
+}
+
+type ExportState = {
+  completedChatIDs: string[]
+  createdAt: string
+  exportVersion: 1
+  chats: Record<string, ChatState>
+}
+
+type ChatState = {
+  attachmentCount: number
+  complete: boolean
+  cursor: string | null
+  error?: string
+  messageCount: number
+  startedAt: string
+  updatedAt: string
+}
+
+type ExportManifest = {
+  accounts: unknown[]
+  attachmentCount: number
+  chatCount: number
+  completedAt: string
+  createdAt: string
+  messageCount: number
+  version: 1
+}
+
+type AttachmentExport = {
+  attachment: Attachment
+  index: number
+  kind: 'attachment' | 'poster'
+  messageID: string
+  path: string
+  sourceURL: string
+}
+
+export async function exportBeeperData(client: any, options: ExportOptions): Promise<ExportManifest> {
+  await mkdir(options.outDir, { recursive: true })
+  await mkdir(join(options.outDir, 'chats'), { recursive: true })
+
+  const statePath = join(options.outDir, '.beeper-export-state.json')
+  const state = options.force ? createState() : await readState(statePath)
+  const startedAt = state.createdAt
+
+  progress(options, `Export directory: ${options.outDir}`)
+  const accounts = await client.accounts.list()
+  await writeJSONAtomic(join(options.outDir, 'accounts.json'), accounts)
+  progress(options, `Accounts: ${accounts.length}`)
+
+  const chats = await collectChats(client, options)
+  await writeJSONAtomic(join(options.outDir, 'chats.json'), chats)
+  progress(options, `Chats queued: ${chats.length}`)
+
+  let totalMessages = 0
+  let totalAttachments = 0
+
+  for (const [index, listedChat] of chats.entries()) {
+    const chatID = String(listedChat.id)
+    const chatDir = join(options.outDir, 'chats', safeSegment(chatID))
+    const chatState = state.chats[chatID]
+    if (!options.force && chatState?.complete && state.completedChatIDs.includes(chatID)) {
+      totalMessages += chatState.messageCount
+      totalAttachments += chatState.attachmentCount
+      progress(options, `[${index + 1}/${chats.length}] ${chatTitle(listedChat)} already complete`)
+      continue
+    }
+
+    progress(options, `[${index + 1}/${chats.length}] ${chatTitle(listedChat)} starting`)
+    if (options.force) await rm(chatDir, { recursive: true, force: true })
+    await mkdir(chatDir, { recursive: true })
+    await mkdir(join(chatDir, 'attachments'), { recursive: true })
+
+    const chat = await client.chats.retrieve(chatID, {
+      maxParticipantCount: options.maxParticipants,
+    })
+    await writeJSONAtomic(join(chatDir, 'chat.json'), chat)
+
+    state.chats[chatID] ??= {
+      attachmentCount: 0,
+      complete: false,
+      cursor: null,
+      messageCount: 0,
+      startedAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    }
+    state.chats[chatID]!.complete = false
+    delete state.chats[chatID]!.error
+    await writeJSONAtomic(statePath, state)
+
+    try {
+      const result = await exportChatMessages(client, chat, chatDir, state, statePath, options)
+      state.chats[chatID] = {
+        ...state.chats[chatID]!,
+        attachmentCount: result.attachmentCount,
+        complete: true,
+        cursor: null,
+        messageCount: result.messages.length,
+        updatedAt: new Date().toISOString(),
+      }
+      state.completedChatIDs = Array.from(new Set([...state.completedChatIDs, chatID]))
+      await writeJSONAtomic(join(chatDir, 'messages.json'), result.messages)
+      await writeFileAtomic(join(chatDir, 'messages.markdown'), renderMarkdown(chat, result.messages, result.attachments))
+      await writeFileAtomic(join(chatDir, 'messages.html'), renderHTML(chat, result.messages, result.attachments))
+      await rm(join(chatDir, 'messages.partial.jsonl'), { force: true })
+      await writeJSONAtomic(statePath, state)
+      totalMessages += result.messages.length
+      totalAttachments += result.attachmentCount
+      progress(options, `[${index + 1}/${chats.length}] ${chatTitle(chat)} complete: ${result.messages.length} messages, ${result.attachmentCount} attachments`)
+    } catch (error) {
+      state.chats[chatID] = {
+        ...state.chats[chatID]!,
+        complete: false,
+        error: error instanceof Error ? error.message : String(error),
+        updatedAt: new Date().toISOString(),
+      }
+      await writeJSONAtomic(statePath, state)
+      throw error
+    }
+  }
+
+  const manifest: ExportManifest = {
+    accounts,
+    attachmentCount: totalAttachments,
+    chatCount: chats.length,
+    completedAt: new Date().toISOString(),
+    createdAt: startedAt,
+    messageCount: totalMessages,
+    version: 1,
+  }
+  await writeJSONAtomic(join(options.outDir, 'manifest.json'), manifest)
+  progress(options, `Done: ${manifest.chatCount} chats, ${manifest.messageCount} messages, ${manifest.attachmentCount} attachments`)
+  return manifest
+}
+
+async function collectChats(client: any, options: ExportOptions): Promise<Chat[]> {
+  if (options.chatIDs?.length) {
+    return Promise.all(options.chatIDs.map(chatID =>
+      client.chats.retrieve(chatID, { maxParticipantCount: 0 }) as Promise<Chat>,
+    ))
+  }
+
+  const chats: Chat[] = []
+  for await (const chat of client.chats.list({ accountIDs: options.accountIDs })) {
+    chats.push(chat)
+    if (options.limitChats && chats.length >= options.limitChats) break
+  }
+  return chats
+}
+
+async function exportChatMessages(
+  client: any,
+  chat: Chat,
+  chatDir: string,
+  state: ExportState,
+  statePath: string,
+  options: ExportOptions,
+): Promise<{ attachmentCount: number; attachments: AttachmentExport[]; messages: Message[] }> {
+  const chatID = chat.id
+  const partialPath = join(chatDir, 'messages.partial.jsonl')
+  const existing = await readJSONL<Message>(partialPath)
+  const seen = new Set(existing.map(message => message.id))
+  const chatState = state.chats[chatID]!
+  let cursor = chatState.cursor
+  let messagesWritten = existing.length
+  let attachmentCount = chatState.attachmentCount
+
+  await mkdir(dirname(partialPath), { recursive: true })
+  const partialHandle = await open(partialPath, 'a')
+  let attachmentManifestHandle: FileHandle | undefined
+  const writeAttachmentEntry = async (entry: AttachmentExport): Promise<void> => {
+    if (!attachmentManifestHandle) {
+      const manifestPath = join(chatDir, 'attachments', 'attachments.jsonl')
+      await mkdir(dirname(manifestPath), { recursive: true })
+      attachmentManifestHandle = await open(manifestPath, 'a')
+    }
+    await attachmentManifestHandle.appendFile(`${JSON.stringify(entry)}\n`)
+  }
+
+  try {
+    while (true) {
+      const page = await client.messages.list(chatID, cursor ? { cursor } : undefined)
+      const items = page.items as Message[]
+      if (!items.length) break
+
+      for (const message of items) {
+        if (seen.has(message.id)) continue
+        await partialHandle.appendFile(`${JSON.stringify(message)}\n`)
+        seen.add(message.id)
+        existing.push(message)
+        messagesWritten += 1
+
+        if (options.downloadAttachments) {
+          const downloaded = await downloadMessageAttachments(client, chatDir, message, writeAttachmentEntry)
+          attachmentCount += downloaded
+        }
+
+        if (options.limitMessages && messagesWritten >= options.limitMessages) break
+      }
+
+      cursor = page.oldestCursor ?? null
+      chatState.cursor = cursor
+      chatState.messageCount = messagesWritten
+      chatState.attachmentCount = attachmentCount
+      chatState.updatedAt = new Date().toISOString()
+      await writeJSONAtomic(statePath, state)
+      progress(options, `  ${chatTitle(chat)}: ${messagesWritten} messages${options.downloadAttachments ? `, ${attachmentCount} attachments` : ''}`)
+
+      if (options.limitMessages && messagesWritten >= options.limitMessages) break
+      if (!page.hasMore || !cursor) break
+    }
+  } finally {
+    await partialHandle.close()
+    if (attachmentManifestHandle) await attachmentManifestHandle.close()
+  }
+
+  existing.sort((a, b) => String(a.sortKey || a.timestamp).localeCompare(String(b.sortKey || b.timestamp)))
+  const allAttachments = await readAttachmentsManifest(chatDir)
+  return { attachmentCount, attachments: allAttachments, messages: existing }
+}
+
+async function downloadMessageAttachments(
+  client: any,
+  chatDir: string,
+  message: Message,
+  writeEntry: (entry: AttachmentExport) => Promise<void>,
+): Promise<number> {
+  const attachments = message.attachments ?? []
+  let count = 0
+  for (const [index, attachment] of attachments.entries()) {
+    const sourceURL = attachment.id || attachment.srcURL
+    if (sourceURL) {
+      const path = await downloadURL(client, sourceURL, chatDir, message.id, index, attachment.fileName, attachment.mimeType)
+      if (path) {
+        await writeEntry({ attachment, index, kind: 'attachment', messageID: message.id, path, sourceURL })
+        count += 1
+      }
+    }
+
+    if (attachment.posterImg) {
+      const path = await downloadURL(client, attachment.posterImg, chatDir, message.id, index, `poster-${attachment.fileName ?? index}`, undefined)
+      if (path) {
+        await writeEntry({ attachment, index, kind: 'poster', messageID: message.id, path, sourceURL: attachment.posterImg })
+        count += 1
+      }
+    }
+  }
+
+  return count
+}
+
+async function downloadURL(
+  client: any,
+  sourceURL: string,
+  chatDir: string,
+  messageID: string,
+  index: number,
+  fileName?: string,
+  mimeType?: string,
+): Promise<string | undefined> {
+  const target = join('attachments', safeSegment(messageID), `${String(index + 1).padStart(2, '0')}-${safeFileName(fileName || fileNameFromURL(sourceURL, mimeType))}`)
+  const absoluteTarget = join(chatDir, target)
+  if (await exists(absoluteTarget)) return target
+
+  await mkdir(join(chatDir, 'attachments', safeSegment(messageID)), { recursive: true })
+  if (sourceURL.startsWith('file://')) {
+    await copyFile(fileURLToPath(sourceURL), absoluteTarget)
+    return target
+  }
+  if (sourceURL.startsWith('/')) {
+    await copyFile(sourceURL, absoluteTarget)
+    return target
+  }
+
+  const response = sourceURL.startsWith('mxc://') || sourceURL.startsWith('localmxc://')
+    ? await client.assets.serve({ url: sourceURL })
+    : await fetch(sourceURL)
+  if (!response.ok) throw new Error(`Failed to download ${sourceURL}: HTTP ${response.status}`)
+  await writeResponseBody(response, absoluteTarget)
+  return target
+}
+
+async function writeResponseBody(response: Response, path: string): Promise<void> {
+  if (!response.body) {
+    await writeFile(path, Buffer.from(await response.arrayBuffer()))
+    return
+  }
+
+  const stream = createWriteStream(path)
+  await new Promise<void>((resolve, reject) => {
+    stream.on('error', reject)
+    stream.on('finish', resolve)
+    const reader = response.body!.getReader()
+    const pump = (): void => {
+      reader.read().then(({ done, value }) => {
+        if (done) {
+          stream.end()
+          return
+        }
+        stream.write(Buffer.from(value), error => {
+          if (error) reject(error)
+          else pump()
+        })
+      }, reject)
+    }
+    pump()
+  })
+}
+
+function renderMarkdown(chat: Chat, messages: Message[], attachments: AttachmentExport[]): string {
+  const byMessage = new Map<string, AttachmentExport[]>()
+  for (const attachment of attachments) {
+    const list = byMessage.get(attachment.messageID) ?? []
+    list.push(attachment)
+    byMessage.set(attachment.messageID, list)
+  }
+
+  const lines = [
+    `# ${escapeMarkdown(chat.title || chat.id)}`,
+    '',
+    `- Chat ID: \`${chat.id}\``,
+    `- Account ID: \`${chat.accountID}\``,
+    `- Network: ${escapeMarkdown(chat.network ?? '')}`,
+    `- Type: ${chat.type}`,
+    `- Messages: ${messages.length}`,
+    '',
+    '## Messages',
+    '',
+  ]
+
+  for (const message of messages) {
+    const sender = message.senderName || message.senderID || 'Unknown sender'
+    lines.push(`### ${escapeMarkdown(sender)} - ${message.timestamp}`)
+    if (message.text) lines.push('', message.text)
+    const messageAttachments = byMessage.get(message.id) ?? []
+    for (const item of messageAttachments) {
+      lines.push('', `- [${escapeMarkdown(item.attachment.fileName || item.kind)}](${encodeURI(item.path)})`)
+    }
+    lines.push('')
+  }
+
+  return `${lines.join('\n').trimEnd()}\n`
+}
+
+function renderHTML(chat: Chat, messages: Message[], attachments: AttachmentExport[]): string {
+  const byMessage = new Map<string, AttachmentExport[]>()
+  for (const attachment of attachments) {
+    const list = byMessage.get(attachment.messageID) ?? []
+    list.push(attachment)
+    byMessage.set(attachment.messageID, list)
+  }
+
+  const rows = messages.map(message => {
+    const sender = message.senderName || message.senderID || 'Unknown sender'
+    const messageAttachments = byMessage.get(message.id) ?? []
+    const attachmentsHTML = messageAttachments.length
+      ? `<ul class="attachments">${messageAttachments.map(item => `<li><a href="${escapeAttribute(item.path)}">${escapeHTML(item.attachment.fileName || item.kind)}</a></li>`).join('')}</ul>`
+      : ''
+    return [
+      '<article class="message">',
+      `  <header><strong>${escapeHTML(sender)}</strong><time datetime="${escapeAttribute(message.timestamp)}">${escapeHTML(message.timestamp)}</time></header>`,
+      message.text ? `  <div class="body">${formatMessageHTML(message.text)}</div>` : '',
+      attachmentsHTML,
+      '</article>',
+    ].filter(Boolean).join('\n')
+  }).join('\n')
+
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${escapeHTML(chat.title || chat.id)}</title>
+  <style>
+    :root { color-scheme: light dark; }
+    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; line-height: 1.45; margin: 0; color: CanvasText; background: Canvas; }
+    main { max-width: 920px; margin: 0 auto; padding: 32px 20px; }
+    h1 { font-size: 28px; margin: 0 0 8px; }
+    .meta { color: color-mix(in srgb, CanvasText 70%, Canvas); display: grid; gap: 4px; margin: 0 0 28px; }
+    .message { border-top: 1px solid color-mix(in srgb, CanvasText 18%, Canvas); padding: 16px 0; }
+    header { display: flex; flex-wrap: wrap; gap: 8px 12px; align-items: baseline; margin-bottom: 8px; }
+    time { color: color-mix(in srgb, CanvasText 62%, Canvas); font-size: 13px; }
+    .body { overflow-wrap: anywhere; }
+    .attachments { margin: 10px 0 0; padding-left: 22px; }
+    a { color: LinkText; }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>${escapeHTML(chat.title || chat.id)}</h1>
+    <section class="meta" aria-label="Chat metadata">
+      <span>Chat ID: <code>${escapeHTML(chat.id)}</code></span>
+      <span>Account ID: <code>${escapeHTML(chat.accountID)}</code></span>
+      <span>Network: ${escapeHTML(chat.network ?? '')}</span>
+      <span>Type: ${escapeHTML(chat.type)}</span>
+      <span>Messages: ${messages.length}</span>
+    </section>
+    <section class="messages">
+${indent(rows, 6)}
+    </section>
+  </main>
+</body>
+</html>
+`
+}
+
+async function readAttachmentsManifest(chatDir: string): Promise<AttachmentExport[]> {
+  return readJSONL<AttachmentExport>(join(chatDir, 'attachments', 'attachments.jsonl'))
+}
+
+async function readJSONL<T>(path: string): Promise<T[]> {
+  try {
+    const content = await readFile(path, 'utf8')
+    return content.split('\n').filter(Boolean).map(line => JSON.parse(line) as T)
+  } catch (error: any) {
+    if (error?.code === 'ENOENT') return []
+    throw error
+  }
+}
+
+async function readState(path: string): Promise<ExportState> {
+  try {
+    return JSON.parse(await readFile(path, 'utf8')) as ExportState
+  } catch (error: any) {
+    if (error?.code === 'ENOENT') return createState()
+    throw error
+  }
+}
+
+function createState(): ExportState {
+  return {
+    chats: {},
+    completedChatIDs: [],
+    createdAt: new Date().toISOString(),
+    exportVersion: 1,
+  }
+}
+
+async function writeJSONAtomic(path: string, value: unknown): Promise<void> {
+  await writeFileAtomic(path, `${JSON.stringify(value, null, 2)}\n`)
+}
+
+async function writeFileAtomic(path: string, content: string): Promise<void> {
+  await mkdir(dirname(path), { recursive: true })
+  const tmp = `${path}.tmp-${process.pid}`
+  await writeFile(tmp, content)
+  await rename(tmp, path)
+}
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await stat(path)
+    return true
+  } catch (error: any) {
+    if (error?.code === 'ENOENT') return false
+    throw error
+  }
+}
+
+function safeSegment(value: string): string {
+  const normalized = value.replace(/[^a-zA-Z0-9._-]+/g, '_').replace(/^_+|_+$/g, '')
+  return normalized.slice(0, 120) || 'item'
+}
+
+function safeFileName(value: string): string {
+  const normalized = basename(value).replace(/[/\\?%*:|"<>]+/g, '_').trim()
+  return normalized.slice(0, 160) || 'attachment'
+}
+
+function fileNameFromURL(url: string, mimeType?: string): string {
+  try {
+    const parsed = new URL(url)
+    const name = basename(parsed.pathname)
+    if (name) return name
+  } catch { /* fall through */ }
+  return `attachment${extensionForMimeType(mimeType)}`
+}
+
+const mimeExtensions: Record<string, string> = {
+  'image/jpeg': '.jpg',
+  'image/png': '.png',
+  'image/gif': '.gif',
+  'video/mp4': '.mp4',
+  'audio/mpeg': '.mp3',
+}
+
+function extensionForMimeType(mimeType?: string): string {
+  if (!mimeType) return ''
+  if (mimeExtensions[mimeType]) return mimeExtensions[mimeType]!
+  const subtype = mimeType.split('/')[1]
+  return subtype && !subtype.includes('+') ? `.${subtype}` : ''
+}
+
+function chatTitle(chat: Pick<Chat, 'id' | 'network' | 'title'>): string {
+  return `${chat.title || chat.id}${chat.network ? ` (${chat.network})` : ''}`
+}
+
+function escapeMarkdown(value: string): string {
+  return value.replace(/([\\`*_{}[\]()#+.!|-])/g, '\\$1')
+}
+
+function escapeHTML(value: string): string {
+  return value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;')
+}
+
+function escapeAttribute(value: string): string {
+  return escapeHTML(encodeURI(value))
+}
+
+function formatMessageHTML(value: string): string {
+  return escapeHTML(value).replaceAll('\n', '<br>')
+}
+
+function indent(value: string, spaces: number): string {
+  const padding = ' '.repeat(spaces)
+  return value.split('\n').map(line => line ? `${padding}${line}` : line).join('\n')
+}
+
+function progress(options: ExportOptions, message: string): void {
+  if (!options.quiet) process.stderr.write(`${message}\n`)
+}
diff --git a/src/lib/ink/components.tsx b/src/lib/ink/components.tsx
new file mode 100644
index 0000000..8ed9609
--- /dev/null
+++ b/src/lib/ink/components.tsx
@@ -0,0 +1,789 @@
+import React from 'react'
+import { Box, Text } from 'ink'
+import { bridgeColor, glyphs, senderColor, theme } from './theme.js'
+
+// OSC 8 hyperlink — modern terminals (iTerm, Ghostty, WezTerm, VS Code, etc.)
+// render this as clickable; everything else ignores the escapes and shows the
+// label text once.
+const supportsHyperlinks = process.stdout.isTTY && process.env.TERM !== 'dumb'
+const OSC8_START = ']8;;'
+const OSC8_END = ']8;;'
+const BEL = ''
+const Hyperlink: React.FC<{ url: string; children?: React.ReactNode }> = ({ url, children }) => {
+  if (!supportsHyperlinks) return <>{children ?? url}</>
+  return <Text>{OSC8_START}{url}{BEL}{children ?? url}{OSC8_END}</Text>
+}
+
+import {
+  attachmentLabel,
+  chatPreview,
+  compact,
+  formatBytes,
+  formatDuration,
+  formatTime,
+  isArchived,
+  isLowPriority,
+  isMuted,
+  isPinned,
+  messageText,
+  participantsSummary,
+  type RecordValue,
+  shortID,
+  stringValue,
+} from './format.js'
+
+// ─── primitives ────────────────────────────────────────────────────────────────
+
+export const Rail: React.FC<{ color: string }> = ({ color }) => (
+  <Text color={color}>{glyphs.rail}</Text>
+)
+
+export const Hairline: React.FC<{ width?: number }> = ({ width = 60 }) => (
+  <Text color={theme.hairline}>{glyphs.hairline.repeat(width)}</Text>
+)
+
+export const Meta: React.FC<{ children: React.ReactNode }> = ({ children }) => (
+  <Text color={theme.muted}>{children}</Text>
+)
+
+export const Dim: React.FC<{ children: React.ReactNode }> = ({ children }) => (
+  <Text color={theme.subtle}>{children}</Text>
+)
+
+export const KV: React.FC<{ label: string; value: React.ReactNode; tone?: 'normal' | 'muted' | 'dim'; width?: number }> =
+  ({ label, value, tone = 'normal', width = 12 }) => {
+    const valueColor = tone === 'dim' ? theme.subtle : tone === 'muted' ? theme.muted : theme.text
+    return (
+      <Box marginLeft={2}>
+        <Text color={theme.subtle}>{label.padEnd(width)}</Text>
+        <Text color={valueColor}>{value}</Text>
+      </Box>
+    )
+  }
+
+export const Pill: React.FC<{ color: string; children: React.ReactNode; muted?: boolean }> = ({ color, children, muted }) => (
+  <Text color={muted ? theme.subtle : color} bold={!muted}>
+    {children}
+  </Text>
+)
+
+export type Suggestion = { command: string; hint?: string }
+
+export const Suggestions: React.FC<{ suggestions?: Suggestion[]; label?: string }> = ({ suggestions, label = 'Try' }) => {
+  if (!suggestions?.length) return null
+  return (
+    <Box flexDirection="column" marginTop={1}>
+      <Text color={theme.subtle}>{label}</Text>
+      {suggestions.map(s => (
+        <Box key={s.command}>
+          <Text color={theme.primary}>  {glyphs.arrow} </Text>
+          <Text color={theme.primaryGlow}>{s.command}</Text>
+          {s.hint && <Text color={theme.muted}>  — {s.hint}</Text>}
+        </Box>
+      ))}
+    </Box>
+  )
+}
+
+// ─── empty / success / failure ────────────────────────────────────────────────
+
+export const EmptyState: React.FC<{ title: string; subtitle?: string; suggestions?: Suggestion[] }> = ({ title, subtitle, suggestions }) => (
+  <Box flexDirection="column">
+    <Box>
+      <Rail color={theme.subtle} />
+      <Text> </Text>
+      <Text bold color={theme.text}>{title}</Text>
+    </Box>
+    {subtitle && (
+      <Box marginLeft={2}>
+        <Text color={theme.muted}>{subtitle}</Text>
+      </Box>
+    )}
+    <Suggestions suggestions={suggestions} />
+  </Box>
+)
+
+export const SuccessLine: React.FC<{ message: string; detail?: string; entity?: React.ReactNode }> = ({ message, detail, entity }) => (
+  <Box flexDirection="column">
+    <Box>
+      <Text color={theme.mine}>{glyphs.check}</Text>
+      <Text> </Text>
+      <Text bold color={theme.text}>{message}</Text>
+      {detail && <Text color={theme.muted}>  {detail}</Text>}
+    </Box>
+    {entity && (
+      <Box marginLeft={2} marginTop={1}>
+        {entity}
+      </Box>
+    )}
+  </Box>
+)
+
+export const FailureLine: React.FC<{ message: string; detail?: string }> = ({ message, detail }) => (
+  <Box>
+    <Text color={theme.danger}>{glyphs.cross}</Text>
+    <Text> </Text>
+    <Text bold color={theme.text}>{message}</Text>
+    {detail && <Text color={theme.muted}>  {detail}</Text>}
+  </Box>
+)
+
+export const SectionHeader: React.FC<{ label: string; count?: number }> = ({ label, count }) => (
+  <Box marginTop={1}>
+    <Text color={theme.subtle}>{label.toUpperCase()}</Text>
+    {count != null && <Text color={theme.subtle}>  {count}</Text>}
+  </Box>
+)
+
+// ─── domain rows ───────────────────────────────────────────────────────────────
+
+type RowProps<T> = { item: T }
+
+function chatRailColor(chat: RecordValue, unread: number, mentions: number): string {
+  if (mentions > 0) return theme.mention
+  if (unread > 0) return theme.primary
+  if (isPinned(chat)) return theme.warn
+  const tint = bridgeColor(stringValue(chat.network))
+  return tint ?? theme.subtle
+}
+
+export const ChatRow: React.FC<RowProps<RecordValue>> = ({ item: chat }) => {
+  const unread = Number(chat.unreadCount ?? 0)
+  const mentions = Number(chat.unreadMentionsCount ?? 0)
+  const muted = isMuted(chat)
+  const pinned = isPinned(chat)
+  const archived = isArchived(chat)
+  const lowPriority = isLowPriority(chat)
+  const preview = chatPreview(chat)
+  const lastActivity = formatTime(chat.lastActivity)
+  const network = stringValue(chat.network)
+  const tint = bridgeColor(network)
+  const railColor = chatRailColor(chat, unread, mentions)
+
+  const titleNode = (
+    <Text bold={unread > 0} color={muted ? theme.muted : theme.text}>{String(chat.title)}</Text>
+  )
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Box>
+        <Rail color={railColor} />
+        <Text> </Text>
+        {titleNode}
+        {network && <Text color={tint ?? theme.subtle}>  {network.toLowerCase()}</Text>}
+        {pinned && <Text color={theme.warn}>  {glyphs.pin}</Text>}
+        {muted && <Text color={theme.magenta}>  {glyphs.mute}</Text>}
+        {archived && <Text color={theme.subtle}>  {glyphs.archive}</Text>}
+        {lowPriority && <Text color={theme.subtle}>  {glyphs.lowPriority}</Text>}
+        <Box flexGrow={1} />
+        {mentions > 0 && (
+          <Text color={theme.mention} bold>  {glyphs.mention}{mentions}</Text>
+        )}
+        {unread > 0 && (
+          <Text color={muted ? theme.subtle : theme.primary} bold={!muted}>
+            {' '}{unread}{mentions > 0 ? '' : ` unread`}
+          </Text>
+        )}
+        {lastActivity && (
+          <Text color={theme.subtle}>  {lastActivity}</Text>
+        )}
+      </Box>
+      {preview && (
+        <Box marginLeft={2}>
+          {preview.kind === 'draft' ? (
+            <Text>
+              <Text italic color={theme.draft}>draft</Text>
+              <Text color={theme.muted}>{preview.text ? `  ${preview.text}` : ''}</Text>
+            </Text>
+          ) : (
+            <Text color={theme.muted}>
+              {preview.sender ? <Text color={theme.subtle}>{preview.sender}  </Text> : null}
+              {preview.text}
+            </Text>
+          )}
+        </Box>
+      )}
+      <Box marginLeft={2}>
+        <Text color={theme.subtle}>{String(chat.id)}</Text>
+      </Box>
+    </Box>
+  )
+}
+
+export const ChatDetail: React.FC<RowProps<RecordValue>> = ({ item: chat }) => {
+  const unread = Number(chat.unreadCount ?? 0)
+  const mentions = Number(chat.unreadMentionsCount ?? 0)
+  const participants = chat.participants && typeof chat.participants === 'object' ? chat.participants as RecordValue : undefined
+  const items = Array.isArray(participants?.items) ? participants!.items as RecordValue[] : []
+  const network = stringValue(chat.network)
+  const tint = bridgeColor(network)
+
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Rail color={chatRailColor(chat, unread, mentions)} />
+        <Text> </Text>
+        <Text bold color={theme.text}>{String(chat.title)}</Text>
+        {network && <Text color={tint ?? theme.subtle}>  {network.toLowerCase()}</Text>}
+        {isPinned(chat) && <Text color={theme.warn}>  {glyphs.pin} pinned</Text>}
+        {isMuted(chat) && <Text color={theme.magenta}>  {glyphs.mute} muted</Text>}
+        {isArchived(chat) && <Text color={theme.subtle}>  {glyphs.archive} archived</Text>}
+        {isLowPriority(chat) && <Text color={theme.subtle}>  {glyphs.lowPriority} low-priority</Text>}
+      </Box>
+      {chat.type ? <KV label="type" value={String(chat.type)} tone="muted" /> : null}
+      {chat.lastActivity ? <KV label="last" value={formatTime(chat.lastActivity) ?? String(chat.lastActivity)} tone="muted" /> : null}
+      {unread > 0 && <KV label="unread" value={`${unread}${mentions > 0 ? ` (${mentions} @)` : ''}`} />}
+      {participants && (
+        <KV label="people" value={participantsSummary(participants) ?? `${items.length}`} tone="muted" />
+      )}
+      {items.length > 0 && (
+        <Box flexDirection="column" marginTop={1}>
+          <Box marginLeft={2}><Text color={theme.subtle}>PARTICIPANTS</Text></Box>
+          {items.slice(0, 20).map((p, i) => (
+            <Box key={i} marginLeft={2}>
+              <Text color={senderColor(stringValue(p.id))}>{glyphs.bullet}</Text>
+              <Text>  </Text>
+              <Text color={theme.text}>{stringValue(p.fullName) ?? stringValue(p.username) ?? shortID(String(p.id))}</Text>
+              {p.isSelf ? <Text color={theme.mine}>  you</Text> : null}
+            </Box>
+          ))}
+          {items.length > 20 && <Box marginLeft={2}><Text color={theme.subtle}>… {items.length - 20} more</Text></Box>}
+        </Box>
+      )}
+      <Box marginLeft={2} marginTop={1}>
+        <Text color={theme.subtle}>id    </Text>
+        <Text color={theme.text}>{String(chat.id)}</Text>
+      </Box>
+      {chat.accountID ? (
+        <Box marginLeft={2}>
+          <Text color={theme.subtle}>acct  </Text>
+          <Text color={theme.muted}>{String(chat.accountID)}</Text>
+        </Box>
+      ) : null}
+    </Box>
+  )
+}
+
+export const MessageRow: React.FC<RowProps<RecordValue>> = ({ item: message }) => {
+  const mine = Boolean(message.isSender)
+  const senderID = stringValue(message.senderID)
+  const sender = stringValue(message.senderName) ?? (senderID ? shortID(senderID) : 'unknown')
+  const text = messageText(message)
+  const timestamp = formatTime(message.timestamp)
+  const status = typeof message.sendStatus === 'object' && message.sendStatus ? message.sendStatus as RecordValue : undefined
+  const showFailure = status?.status && status.status !== 'SUCCESS'
+  const attachments = Array.isArray(message.attachments) ? message.attachments : []
+  const reactions = Array.isArray(message.reactions) ? message.reactions : []
+  const railColor = mine ? theme.mine : senderColor(senderID)
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Box>
+        <Rail color={railColor} />
+        <Text> </Text>
+        <Text bold color={mine ? theme.mine : railColor}>{mine ? 'you' : sender}</Text>
+        {message.type != null && message.type !== 'TEXT' ? (
+          <Text color={theme.magenta}>  {String(message.type).toLowerCase()}</Text>
+        ) : null}
+        {message.isUnread ? (
+          <Text color={theme.primary}>  {glyphs.unread} unread</Text>
+        ) : null}
+        {message.isDeleted ? (
+          <Text color={theme.danger}>  deleted</Text>
+        ) : null}
+        {message.editedTimestamp ? (
+          <Text color={theme.subtle}>  {glyphs.edited} edited</Text>
+        ) : null}
+        {attachments.length > 0 && (
+          <Text color={theme.warn}>  {glyphs.attachment} {attachmentLabel(attachments)}</Text>
+        )}
+        {reactions.length > 0 && (
+          <Text color={theme.magenta}>  {glyphs.reaction}{reactions.length}</Text>
+        )}
+        <Box flexGrow={1} />
+        {timestamp && <Text color={theme.subtle}>{timestamp}</Text>}
+      </Box>
+      {text && (
+        <Box marginLeft={2}>
+          <Text color={theme.text}>{text}</Text>
+        </Box>
+      )}
+      {showFailure ? (
+        <Box marginLeft={2}>
+          <Text color={theme.danger}>{glyphs.cross} {String(status?.status)}</Text>
+          {status?.message ? <Text color={theme.muted}>  {String(status.message)}</Text> : null}
+        </Box>
+      ) : null}
+      <Box marginLeft={2}>
+        <Text color={theme.subtle}>{String(message.id)}</Text>
+        {message.chatID ? <Text color={theme.subtle}>  in {String(message.chatID)}</Text> : null}
+      </Box>
+    </Box>
+  )
+}
+
+export const UserRow: React.FC<RowProps<RecordValue>> = ({ item: user }) => {
+  const title = stringValue(user.fullName)
+    ?? stringValue(user.username)
+    ?? stringValue(user.email)
+    ?? stringValue(user.phoneNumber)
+    ?? String(user.id)
+  const handles = compact([
+    user.username ? `@${user.username}` : undefined,
+    user.email ? String(user.email) : undefined,
+    user.phoneNumber ? String(user.phoneNumber) : undefined,
+  ])
+  const rail = user.isSelf ? theme.mine : senderColor(stringValue(user.id))
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Box>
+        <Rail color={rail} />
+        <Text> </Text>
+        <Text bold color={theme.text}>{title}</Text>
+        {user.isSelf ? <Text color={theme.mine}>  you</Text> : null}
+        {user.cannotMessage ? <Text color={theme.danger}>  cannot message</Text> : null}
+      </Box>
+      {handles.length > 0 ? (
+        <Box marginLeft={2}>
+          <Text color={theme.muted}>{handles.join('  ')}</Text>
+        </Box>
+      ) : null}
+      <Box marginLeft={2}>
+        <Text color={theme.subtle}>{String(user.id)}</Text>
+        {user.accountID ? <Text color={theme.subtle}>  on {String(user.accountID)}</Text> : null}
+      </Box>
+    </Box>
+  )
+}
+
+export const AccountRow: React.FC<RowProps<RecordValue>> = ({ item: account }) => {
+  const id = account.accountID ?? account.id
+  const title = stringValue(account.displayName)
+    ?? stringValue(account.name)
+    ?? stringValue(account.network)
+    ?? String(id)
+  const network = stringValue(account.network)
+  const tint = bridgeColor(network)
+  const state = stringValue(account.state)
+  const stateLow = state?.toLowerCase() ?? ''
+  const connected = stateLow.includes('online') || stateLow.includes('connect')
+  const errored = stateLow.includes('error') || stateLow.includes('fail')
+  const stateTone = connected ? theme.mine : errored ? theme.danger : theme.warnAlt
+  const handles = compact([
+    account.username ? `@${account.username}` : undefined,
+    stringValue(account.userID),
+  ])
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Box>
+        <Rail color={tint ?? theme.primary} />
+        <Text> </Text>
+        <Text bold color={theme.text}>{title}</Text>
+        {network && <Text color={tint ?? theme.muted}>  {network.toLowerCase()}</Text>}
+        {state && <Text color={stateTone}>  {connected ? glyphs.dot : errored ? glyphs.cross : glyphs.ring} {stateLow}</Text>}
+      </Box>
+      {handles.length > 0 && (
+        <Box marginLeft={2}>
+          <Text color={theme.muted}>{handles.join('  ')}</Text>
+        </Box>
+      )}
+      <Box marginLeft={2}>
+        <Text color={theme.subtle}>{String(id)}</Text>
+        {account.bridge ? <Text color={theme.subtle}>  bridge {String(account.bridge)}</Text> : null}
+      </Box>
+    </Box>
+  )
+}
+
+export const AssetRow: React.FC<RowProps<RecordValue>> = ({ item: asset }) => {
+  const title = stringValue(asset.fileName)
+    ?? stringValue(asset.uploadID)
+    ?? stringValue(asset.srcURL)
+    ?? 'asset'
+  const mime = stringValue(asset.mimeType)
+  const meta = compact([
+    typeof asset.fileSize === 'number' ? formatBytes(asset.fileSize) : undefined,
+    asset.width && asset.height ? `${String(asset.width)}×${String(asset.height)}` : undefined,
+    typeof asset.duration === 'number' ? formatDuration(asset.duration) : undefined,
+  ])
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Box>
+        <Rail color={asset.error ? theme.danger : theme.cyan} />
+        <Text> </Text>
+        <Text bold color={theme.text}>{title}</Text>
+        {mime && <Text color={theme.subtle}>  {mime}</Text>}
+        {meta.length > 0 && <Text color={theme.muted}>  {meta.join('  ')}</Text>}
+      </Box>
+      {asset.srcURL ? (
+        <Box marginLeft={2}>
+          <Hyperlink url={String(asset.srcURL)}><Text color={theme.subtle}>{String(asset.srcURL)}</Text></Hyperlink>
+        </Box>
+      ) : null}
+      {asset.uploadID ? (
+        <Box marginLeft={2}>
+          <Text color={theme.subtle}>upload {String(asset.uploadID)}</Text>
+        </Box>
+      ) : null}
+      {asset.error ? (
+        <Box marginLeft={2}>
+          <Text color={theme.danger}>{glyphs.cross} {String(asset.error)}</Text>
+        </Box>
+      ) : null}
+    </Box>
+  )
+}
+
+// ─── system / cards ────────────────────────────────────────────────────────────
+
+export const InfoCard: React.FC<{ info: RecordValue }> = ({ info }) => {
+  const version = stringValue(info.version)
+  const platform = stringValue(info.platform)
+  const user = info.user && typeof info.user === 'object' ? info.user as RecordValue : undefined
+  const userName = user ? (stringValue(user.fullName) ?? stringValue(user.username) ?? stringValue(user.id)) : undefined
+  const endpoints = info.endpoints && typeof info.endpoints === 'object' ? info.endpoints as RecordValue : undefined
+
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Rail color={theme.primary} />
+        <Text> </Text>
+        <Text bold color={theme.text}>Beeper Desktop</Text>
+        {version && <Text color={theme.muted}>  v{version}</Text>}
+        {platform && <Text color={theme.subtle}>  {platform}</Text>}
+      </Box>
+      {userName && <KV label="user" value={userName} />}
+      {endpoints && Object.entries(endpoints).map(([key, value]) =>
+        typeof value === 'string' ? (
+          <Box marginLeft={2} key={key}>
+            <Text color={theme.subtle}>{key.padEnd(12)}</Text>
+            <Hyperlink url={value.startsWith('ws') ? value.replace(/^ws/, 'http') : value}>
+              <Text color={theme.link}>{value}</Text>
+            </Hyperlink>
+          </Box>
+        ) : null,
+      )}
+    </Box>
+  )
+}
+
+export const DoctorCard: React.FC<{ checks: Array<{ ok: boolean; name: string; detail?: string }>; ok: boolean }> = ({ checks, ok }) => {
+  const longest = Math.max(0, ...checks.map(c => c.name.length))
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Rail color={ok ? theme.mine : theme.danger} />
+        <Text> </Text>
+        <Text bold color={theme.text}>Doctor</Text>
+        <Text>  </Text>
+        {ok ? (
+          <Text color={theme.mine}>{glyphs.check} healthy</Text>
+        ) : (
+          <Text color={theme.danger}>{glyphs.cross} attention needed</Text>
+        )}
+      </Box>
+      <Box flexDirection="column" marginTop={1}>
+        {checks.map(check => (
+          <Box key={check.name} marginLeft={2}>
+            <Text color={check.ok ? theme.mine : theme.danger}>{check.ok ? glyphs.check : glyphs.cross}</Text>
+            <Text>  </Text>
+            <Text color={theme.text}>{check.name.padEnd(longest + 2)}</Text>
+            {check.detail && <Text color={theme.muted}>{check.detail}</Text>}
+          </Box>
+        ))}
+      </Box>
+      {!ok && (
+        <Suggestions suggestions={[
+          { command: 'beeper auth login', hint: 'sign in to Beeper Desktop' },
+          { command: 'beeper status', hint: 'verify the API endpoint' },
+        ]} />
+      )}
+    </Box>
+  )
+}
+
+export const AuthStatusCard: React.FC<{ auth: RecordValue }> = ({ auth }) => {
+  const ok = Boolean(auth.authenticated)
+  const expires = auth.expiresAt ? formatTime(auth.expiresAt) ?? String(auth.expiresAt) : undefined
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Rail color={ok ? theme.mine : theme.warn} />
+        <Text> </Text>
+        <Text bold color={theme.text}>Authentication</Text>
+        <Text>  </Text>
+        {ok ? (
+          <Text color={theme.mine}>{glyphs.check} signed in</Text>
+        ) : (
+          <Text color={theme.warn}>{glyphs.ring} signed out</Text>
+        )}
+      </Box>
+      <KV label="endpoint" value={
+        <Hyperlink url={String(auth.baseURL)}><Text color={theme.link}>{String(auth.baseURL)}</Text></Hyperlink>
+      } />
+      <KV label="source" value={String(auth.source ?? 'none')} tone="muted" />
+      {auth.clientID ? <KV label="client" value={String(auth.clientID)} tone="dim" /> : null}
+      {auth.scope ? <KV label="scope" value={String(auth.scope)} tone="muted" /> : null}
+      {expires ? <KV label="expires" value={expires} tone="muted" /> : null}
+      {!ok && (
+        <Suggestions suggestions={[
+          { command: 'beeper auth login', hint: 'sign in to Beeper Desktop' },
+        ]} />
+      )}
+    </Box>
+  )
+}
+
+export const UserInfoCard: React.FC<{ user: RecordValue }> = ({ user }) => {
+  const name = stringValue(user.name)
+    ?? stringValue(user.preferred_username)
+    ?? stringValue(user.email)
+    ?? String(user.sub)
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Rail color={theme.primary} />
+        <Text> </Text>
+        <Text bold color={theme.text}>{name}</Text>
+        <Text color={theme.subtle}>  you</Text>
+      </Box>
+      {user.email ? <KV label="email" value={String(user.email)} /> : null}
+      {user.preferred_username ? <KV label="username" value={`@${String(user.preferred_username)}`} tone="muted" /> : null}
+      {user.sub ? <KV label="sub" value={String(user.sub)} tone="dim" /> : null}
+    </Box>
+  )
+}
+
+// ─── auth flow / login wizard ──────────────────────────────────────────────────
+
+export const AuthCodeCard: React.FC<{ url: string; code?: string; hint?: string }> = ({ url, code, hint }) => (
+  <Box flexDirection="column">
+    <Box>
+      <Rail color={theme.primary} />
+      <Text> </Text>
+      <Text bold color={theme.text}>Sign in to Beeper</Text>
+    </Box>
+    {hint && (
+      <Box marginLeft={2}>
+        <Text color={theme.muted}>{hint}</Text>
+      </Box>
+    )}
+    <Box marginLeft={2} marginTop={1}>
+      <Hyperlink url={url}><Text color={theme.link} underline>{url}</Text></Hyperlink>
+    </Box>
+    {code && (
+      <Box marginLeft={2} marginTop={1}>
+        <Text color={theme.subtle}>code  </Text>
+        <Text bold color={theme.warn}>{code}</Text>
+      </Box>
+    )}
+  </Box>
+)
+
+export const AuthSignedIn: React.FC<{ as: string; detail?: string; saved?: boolean }> = ({ as, detail, saved }) => (
+  <Box flexDirection="column">
+    <Box>
+      <Text color={theme.mine}>{glyphs.check}</Text>
+      <Text> </Text>
+      <Text bold color={theme.text}>Signed in</Text>
+      <Text color={theme.muted}>  as </Text>
+      <Text color={theme.text}>{as}</Text>
+    </Box>
+    {detail && <Box marginLeft={2}><Text color={theme.muted}>{detail}</Text></Box>}
+    {saved === false && <Box marginLeft={2}><Text color={theme.warn}>token not saved (--no-save)</Text></Box>}
+  </Box>
+)
+
+// ─── config / commands manifest ────────────────────────────────────────────────
+
+function maskToken(value: string): string {
+  if (value.length <= 12) return '••••'
+  return `${value.slice(0, 6)}…${value.slice(-4)}`
+}
+
+function renderConfigValue(key: string, value: unknown): React.ReactNode {
+  if (value == null) return <Text color={theme.subtle}>—</Text>
+  if (typeof value !== 'object') {
+    if (/token|secret|key/i.test(key) && typeof value === 'string') {
+      return <Text color={theme.subtle}>{maskToken(value)}</Text>
+    }
+    return <Text color={theme.text}>{String(value)}</Text>
+  }
+  const record = value as RecordValue
+  const inner = Object.entries(record).filter(([, v]) => v != null)
+  if (!inner.length) return <Text color={theme.subtle}>{'{}'}</Text>
+  const width = Math.max(...inner.map(([k]) => k.length)) + 2
+  return (
+    <Box flexDirection="column">
+      {inner.map(([k, v]) => (
+        <Box key={k}>
+          <Text color={theme.subtle}>{k.padEnd(width)}</Text>
+          {/^(accesstoken|token|secret|key)$/i.test(k) && typeof v === 'string'
+            ? <Text color={theme.subtle}>{maskToken(v)}</Text>
+            : <Text color={theme.text}>{typeof v === 'object' ? JSON.stringify(v) : String(v)}</Text>}
+        </Box>
+      ))}
+    </Box>
+  )
+}
+
+export const ConfigView: React.FC<{ data: RecordValue }> = ({ data }) => {
+  const entries = Object.entries(data).filter(([, v]) => v != null)
+  if (!entries.length) {
+    return <EmptyState title="No config set" subtitle="The CLI is using defaults." suggestions={[
+      { command: 'beeper config set baseURL <url>', hint: 'override the API endpoint' },
+    ]} />
+  }
+  const width = Math.max(...entries.map(([k]) => k.length)) + 2
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Rail color={theme.primary} />
+        <Text> </Text>
+        <Text bold color={theme.text}>Config</Text>
+      </Box>
+      {entries.map(([key, value]) => (
+        <Box key={key} marginLeft={2} flexDirection={typeof value === 'object' && value != null ? 'column' : 'row'}>
+          <Box>
+            <Text color={theme.subtle}>{key.padEnd(width)}</Text>
+            {typeof value !== 'object' || value == null ? renderConfigValue(key, value) : null}
+          </Box>
+          {typeof value === 'object' && value != null && (
+            <Box marginLeft={width + 2}>
+              {renderConfigValue(key, value)}
+            </Box>
+          )}
+        </Box>
+      ))}
+    </Box>
+  )
+}
+
+type ManifestItem = { command: string; description: string; group?: string }
+
+export const CommandsView: React.FC<{ items: ManifestItem[]; title?: string; intro?: string[] }> = ({ items, title = 'Commands', intro }) => {
+  const groups = new Map<string, ManifestItem[]>()
+  for (const item of items) {
+    const g = item.group ?? 'Common'
+    if (!groups.has(g)) groups.set(g, [])
+    groups.get(g)!.push(item)
+  }
+  // Hard cap so descriptions stay aligned. Anything longer drops its description onto the next indented line.
+  const NAME_WIDTH = 32
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Rail color={theme.primary} />
+        <Text> </Text>
+        <Text bold color={theme.text}>{title}</Text>
+      </Box>
+      {intro?.map((line, i) => (
+        <Box key={i} marginLeft={2}>
+          <Text color={theme.muted}>{line}</Text>
+        </Box>
+      ))}
+      {[...groups.entries()].map(([group, list]) => (
+        <Box flexDirection="column" key={group} marginTop={1}>
+          <Box marginLeft={2}><Text color={theme.subtle}>{group.toUpperCase()}</Text></Box>
+          {list.map(item => {
+            const fits = item.command.length <= NAME_WIDTH
+            return fits ? (
+              <Box key={item.command} marginLeft={2}>
+                <Text color={theme.primaryGlow}>{item.command.padEnd(NAME_WIDTH + 2)}</Text>
+                <Text color={theme.muted}>{item.description}</Text>
+              </Box>
+            ) : (
+              <Box key={item.command} marginLeft={2} flexDirection="column">
+                <Text color={theme.primaryGlow}>{item.command}</Text>
+                <Box marginLeft={2}><Text color={theme.muted}>{item.description}</Text></Box>
+              </Box>
+            )
+          })}
+        </Box>
+      ))}
+    </Box>
+  )
+}
+
+// ─── stream feed (used by `watch`) ─────────────────────────────────────────────
+
+export type StreamEvent = { type: string; chatID?: string; messageID?: string; ts?: string }
+
+const eventTone: Record<string, string> = {
+  'message.new': theme.primary,
+  'message.send': theme.mine,
+  'message.edit': theme.warn,
+  'message.delete': theme.danger,
+  'chat.update': theme.cyan,
+  'chat.read': theme.subtle,
+  'chat.typing': theme.magenta,
+  'reaction.add': theme.magenta,
+  'reaction.remove': theme.subtle,
+}
+
+export const StreamEventLine: React.FC<{ event: StreamEvent; index: number }> = ({ event, index }) => {
+  const color = eventTone[event.type] ?? theme.primary
+  const time = event.ts ? formatTime(event.ts) : undefined
+  return (
+    <Box>
+      <Text color={theme.subtle}>{String(index).padStart(4)}  </Text>
+      <Text color={color}>{glyphs.dot}</Text>
+      <Text>  </Text>
+      <Text bold color={theme.text}>{event.type}</Text>
+      {event.chatID && <Text color={theme.subtle}>  in {event.chatID}</Text>}
+      {event.messageID && <Text color={theme.subtle}>  msg {event.messageID}</Text>}
+      {time && <Text color={theme.subtle}>  {time}</Text>}
+    </Box>
+  )
+}
+
+export const StreamHeader: React.FC<{ subscribed: string[]; baseURL: string; connected: boolean }> = ({ subscribed, baseURL, connected }) => {
+  const label = subscribed.length === 1 && subscribed[0] === '*' ? 'all chats' : `${subscribed.length} chat${subscribed.length === 1 ? '' : 's'}`
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Box>
+        <Rail color={connected ? theme.mine : theme.warn} />
+        <Text> </Text>
+        <Text bold color={theme.text}>Watching events</Text>
+        <Text color={theme.muted}>  {label}</Text>
+        {!connected && <Text color={theme.warn}>  connecting…</Text>}
+      </Box>
+      <Box marginLeft={2}>
+        <Text color={theme.subtle}>{baseURL}  ·  press ⌃C to stop</Text>
+      </Box>
+    </Box>
+  )
+}
+
+// ─── generic fallback ─────────────────────────────────────────────────────────
+
+export const GenericRow: React.FC<RowProps<RecordValue>> = ({ item }) => {
+  const title = item.title ?? item.displayName ?? item.name ?? item.id ?? item.messageID
+  const scalarEntries = Object.entries(item).filter(([key, value]) => {
+    if (value == null) return false
+    if (key === 'title' || key === 'displayName' || key === 'name') return false
+    if (typeof value === 'object') return false
+    return true
+  })
+  const width = scalarEntries.length ? Math.max(...scalarEntries.map(([k]) => k.length)) + 2 : 0
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      {title != null && (
+        <Box>
+          <Rail color={theme.primary} />
+          <Text> </Text>
+          <Text bold color={theme.text}>{String(title)}</Text>
+        </Box>
+      )}
+      {scalarEntries.map(([key, value]) => (
+        <Box marginLeft={2} key={key}>
+          <Text color={theme.subtle}>{key.padEnd(width)}</Text>
+          <Text color={theme.text}>{String(value)}</Text>
+        </Box>
+      ))}
+    </Box>
+  )
+}
diff --git a/src/lib/ink/format.ts b/src/lib/ink/format.ts
new file mode 100644
index 0000000..64102c8
--- /dev/null
+++ b/src/lib/ink/format.ts
@@ -0,0 +1,121 @@
+export type RecordValue = Record<string, unknown>
+
+export function stringValue(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value : undefined
+}
+
+export function compact(values: unknown[]): string[] {
+  return values.filter((value): value is string => typeof value === 'string' && value.length > 0)
+}
+
+export function formatTime(value: unknown): string | undefined {
+  if (typeof value !== 'string' && typeof value !== 'number') return undefined
+  const date = new Date(value)
+  if (Number.isNaN(date.valueOf())) return String(value)
+  const now = Date.now()
+  const diffMs = now - date.valueOf()
+  const abs = Math.abs(diffMs)
+  const suffix = diffMs >= 0 ? 'ago' : 'from now'
+  if (abs < 60_000) return 'just now'
+  if (abs < 3_600_000) return `${Math.round(abs / 60_000)}m ${suffix}`
+  if (abs < 86_400_000) return `${Math.round(abs / 3_600_000)}h ${suffix}`
+  if (abs < 604_800_000) return `${Math.round(abs / 86_400_000)}d ${suffix}`
+  return date.toLocaleDateString(undefined, {
+    month: 'short',
+    day: 'numeric',
+    year: date.getFullYear() === new Date().getFullYear() ? undefined : 'numeric',
+  })
+}
+
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`
+}
+
+export function formatDuration(ms: number): string {
+  const seconds = Math.round(ms / 1000)
+  if (seconds < 60) return `${seconds}s`
+  const minutes = Math.floor(seconds / 60)
+  const remainder = seconds % 60
+  return `${minutes}m ${remainder}s`
+}
+
+export function shortID(value: string): string {
+  const local = value.split(':')[0]
+  return local?.replace(/^@/, '') || value
+}
+
+export function truncate(value: string, max: number): string {
+  return value.length <= max ? value : `${value.slice(0, max - 1)}…`
+}
+
+export function cleanText(value: unknown): string | undefined {
+  const raw = stringValue(value)
+  if (!raw) return undefined
+  const text = raw
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+    .replace(/[*_`~>#]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+  return text ? truncate(text, 240) : undefined
+}
+
+export function attachmentLabel(attachments: unknown[]): string {
+  const labels = attachments.map(item => {
+    if (!item || typeof item !== 'object') return 'attachment'
+    const attachment = item as RecordValue
+    return stringValue(attachment.fileName) ?? stringValue(attachment.type) ?? 'attachment'
+  })
+  return labels.length === 1 ? labels[0]! : `${labels.length} attachments`
+}
+
+export function messageText(message: RecordValue): string | undefined {
+  if (message.isDeleted) return 'deleted message'
+  const text = cleanText(message.text)
+  if (text) return text
+  if (Array.isArray(message.attachments) && message.attachments.length > 0) return attachmentLabel(message.attachments)
+  if (Array.isArray(message.links) && message.links.length > 0) return `${message.links.length} link${message.links.length === 1 ? '' : 's'}`
+  return undefined
+}
+
+export function chatPreview(chat: RecordValue): { kind: 'draft' | 'message'; sender?: string; text: string } | undefined {
+  if (chat.draft && typeof chat.draft === 'object') {
+    const draft = chat.draft as RecordValue
+    const text = cleanText(draft.text) ?? ''
+    return { kind: 'draft', text }
+  }
+  const lastMessage = (chat.latestMessage ?? chat.lastMessage) as RecordValue | undefined
+  if (lastMessage && typeof lastMessage === 'object') {
+    const sender = stringValue(lastMessage.senderName) ?? (lastMessage.isSender ? 'you' : undefined)
+    const text = messageText(lastMessage) ?? ''
+    if (!text && !sender) return undefined
+    return { kind: 'message', sender, text }
+  }
+  return undefined
+}
+
+export function participantsSummary(participants: RecordValue): string | undefined {
+  const total = participants.total
+  const items = Array.isArray(participants.items) ? participants.items : []
+  if (typeof total === 'number') return `${total} participant${total === 1 ? '' : 's'}`
+  if (items.length) return `${items.length} participant${items.length === 1 ? '' : 's'}`
+  return undefined
+}
+
+export function isPinned(chat: RecordValue): boolean {
+  return Boolean(chat.isPinned ?? chat.pinned)
+}
+
+export function isMuted(chat: RecordValue): boolean {
+  return Boolean(chat.isMuted ?? chat.muted)
+}
+
+export function isArchived(chat: RecordValue): boolean {
+  return Boolean(chat.isArchived ?? chat.archived)
+}
+
+export function isLowPriority(chat: RecordValue): boolean {
+  return Boolean(chat.isLowPriority ?? chat.lowPriority)
+}
diff --git a/src/lib/ink/render.tsx b/src/lib/ink/render.tsx
new file mode 100644
index 0000000..5acd229
--- /dev/null
+++ b/src/lib/ink/render.tsx
@@ -0,0 +1,308 @@
+import React, { useCallback, useEffect, useRef, useState } from 'react'
+import { Box, render as inkRender, Static, Text, useApp, useInput } from 'ink'
+import Spinner from 'ink-spinner'
+import {
+  AccountRow,
+  AssetRow,
+  AuthStatusCard,
+  ChatDetail,
+  ChatRow,
+  CommandsView,
+  ConfigView,
+  DoctorCard,
+  EmptyState,
+  FailureLine,
+  GenericRow,
+  InfoCard,
+  MessageRow,
+  SectionHeader,
+  type StreamEvent,
+  StreamEventLine,
+  StreamHeader,
+  type Suggestion,
+  SuccessLine,
+  UserInfoCard,
+  UserRow,
+} from './components.js'
+import type { RecordValue } from './format.js'
+import { glyphs, theme } from './theme.js'
+
+const App: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+  const { exit } = useApp()
+  useEffect(() => {
+    setTimeout(() => exit(), 0)
+  }, [exit])
+  return <>{children}</>
+}
+
+async function renderOnce(node: React.ReactNode): Promise<void> {
+  const instance = inkRender(<App>{node}</App>, { exitOnCtrlC: false, patchConsole: false })
+  await instance.waitUntilExit().catch(() => undefined)
+}
+
+type Kind =
+  | 'chat' | 'chatDetail' | 'message' | 'user' | 'account' | 'asset'
+  | 'info' | 'doctor' | 'auth' | 'oauth' | 'search'
+  | 'commandManifest' | 'config'
+  | 'generic'
+
+function detectKind(record: RecordValue): Kind {
+  if (typeof record.id === 'string' && typeof record.accountID === 'string' && typeof record.title === 'string' && typeof record.unreadCount === 'number') {
+    if (record.participants && typeof record.participants === 'object') return 'chatDetail'
+    return 'chat'
+  }
+  if (typeof record.id === 'string' && typeof record.chatID === 'string' && typeof record.senderID === 'string' && typeof record.timestamp === 'string') return 'message'
+  if (typeof record.id === 'string' && (typeof record.fullName === 'string' || typeof record.username === 'string' || typeof record.email === 'string' || typeof record.phoneNumber === 'string')) return 'user'
+  if (typeof (record.accountID ?? record.id) === 'string' && (typeof record.network === 'string' || typeof record.bridge === 'string' || typeof record.displayName === 'string')) return 'account'
+  if (typeof record.uploadID === 'string' || typeof record.srcURL === 'string') return 'asset'
+  if (typeof record.version === 'string' && typeof record.endpoints === 'object') return 'info'
+  if (typeof record.ok === 'boolean' && Array.isArray(record.checks)) return 'doctor'
+  if (typeof record.authenticated === 'boolean' && typeof record.baseURL === 'string') return 'auth'
+  if (typeof record.sub === 'string' && (typeof record.email === 'string' || typeof record.name === 'string' || typeof record.preferred_username === 'string')) return 'oauth'
+  if (Array.isArray(record.chats) && Array.isArray(record.messages)) return 'search'
+  return 'generic'
+}
+
+function isManifestList(items: unknown[]): items is Array<{ command: string; description: string; group?: string }> {
+  return items.every(item =>
+    item != null
+    && typeof item === 'object'
+    && typeof (item as Record<string, unknown>).command === 'string'
+    && typeof (item as Record<string, unknown>).description === 'string',
+  )
+}
+
+function rowFor(kind: Kind, item: RecordValue, key: number): React.ReactNode {
+  switch (kind) {
+    case 'chat': return <ChatRow item={item} key={key} />
+    case 'chatDetail': return <ChatDetail item={item} key={key} />
+    case 'message': return <MessageRow item={item} key={key} />
+    case 'user': return <UserRow item={item} key={key} />
+    case 'account': return <AccountRow item={item} key={key} />
+    case 'asset': return <AssetRow item={item} key={key} />
+    default: return <GenericRow item={item} key={key} />
+  }
+}
+
+export async function renderList(items: RecordValue[], empty?: { title: string; subtitle?: string; suggestions?: Suggestion[] }): Promise<void> {
+  if (!items.length) {
+    if (empty) await renderOnce(<EmptyState title={empty.title} subtitle={empty.subtitle} suggestions={empty.suggestions} />)
+    return
+  }
+  if (isManifestList(items)) {
+    await renderOnce(<CommandsView items={items} />)
+    return
+  }
+  const kind = detectKind(items[0]!)
+  await renderOnce(
+    <Box flexDirection="column">
+      {items.map((item, index) => rowFor(kind === 'chatDetail' ? 'chat' : kind, item, index))}
+    </Box>,
+  )
+}
+
+export async function renderValue(value: unknown): Promise<void> {
+  if (Array.isArray(value)) {
+    await renderList(value as RecordValue[])
+    return
+  }
+  if (!value || typeof value !== 'object') {
+    if (value === undefined) return
+    process.stdout.write(`${String(value)}\n`)
+    return
+  }
+  const record = value as RecordValue
+  const kind = detectKind(record)
+  switch (kind) {
+    case 'info':
+      await renderOnce(<InfoCard info={record} />)
+      return
+    case 'doctor': {
+      const checks = (record.checks as Array<{ ok: boolean; name: string; detail?: string }>) ?? []
+      await renderOnce(<DoctorCard checks={checks} ok={Boolean(record.ok)} />)
+      return
+    }
+    case 'auth':
+      await renderOnce(<AuthStatusCard auth={record} />)
+      return
+    case 'oauth':
+      await renderOnce(<UserInfoCard user={record} />)
+      return
+    case 'search': {
+      const chats = Array.isArray(record.chats) ? record.chats as RecordValue[] : []
+      const messages = Array.isArray(record.messages) ? record.messages as RecordValue[] : []
+      if (!chats.length && !messages.length) {
+        await renderOnce(
+          <EmptyState
+            title="Nothing matched your search"
+            subtitle="Try a different query, account, or check spelling."
+            suggestions={[
+              { command: 'beeper chats', hint: 'browse everything' },
+              { command: 'beeper chats search "<term>"', hint: 'narrow with filters' },
+            ]}
+          />,
+        )
+        return
+      }
+      await renderOnce(
+        <Box flexDirection="column">
+          {chats.length > 0 && <SectionHeader label="Chats" count={chats.length} />}
+          {chats.map((item, index) => <ChatRow item={item} key={`c-${index}`} />)}
+          {messages.length > 0 && <SectionHeader label="Messages" count={messages.length} />}
+          {messages.map((item, index) => <MessageRow item={item} key={`m-${index}`} />)}
+        </Box>,
+      )
+      return
+    }
+    case 'chat':
+    case 'chatDetail':
+      await renderOnce(<ChatDetail item={record} />)
+      return
+    case 'message':
+      await renderOnce(<MessageRow item={record} />)
+      return
+    case 'user':
+      await renderOnce(<UserRow item={record} />)
+      return
+    case 'account':
+      await renderOnce(<AccountRow item={record} />)
+      return
+    case 'asset':
+      await renderOnce(<AssetRow item={record} />)
+      return
+    default:
+      await renderOnce(<GenericRow item={record} />)
+  }
+}
+
+export async function renderEmptyState(opts: { title: string; subtitle?: string; suggestions?: Suggestion[] }): Promise<void> {
+  await renderOnce(<EmptyState title={opts.title} subtitle={opts.subtitle} suggestions={opts.suggestions} />)
+}
+
+export async function renderSuccess(opts: { message: string; detail?: string; entity?: unknown }): Promise<void> {
+  let entityNode: React.ReactNode = null
+  if (opts.entity && typeof opts.entity === 'object') {
+    const record = opts.entity as RecordValue
+    const kind = detectKind(record)
+    entityNode = rowFor(kind === 'chatDetail' ? 'chat' : kind, record, 0)
+  }
+  await renderOnce(<SuccessLine message={opts.message} detail={opts.detail} entity={entityNode} />)
+}
+
+export async function renderFailure(opts: { message: string; detail?: string }): Promise<void> {
+  await renderOnce(<FailureLine message={opts.message} detail={opts.detail} />)
+}
+
+export async function renderConfig(data: RecordValue): Promise<void> {
+  await renderOnce(<ConfigView data={data} />)
+}
+
+export async function renderCommands(items: Array<{ command: string; description: string; group?: string }>, opts?: { title?: string; intro?: string[] }): Promise<void> {
+  await renderOnce(<CommandsView items={items} title={opts?.title} intro={opts?.intro} />)
+}
+
+// ─── streaming render (used by `watch`) ───────────────────────────────────────
+
+export type StreamController = {
+  push(event: StreamEvent): void
+  setConnected(connected: boolean): void
+  setStatus(status: string | undefined): void
+  close(): Promise<void>
+  done: Promise<void>
+}
+
+type StreamState = {
+  events: StreamEvent[]
+  connected: boolean
+  status: string | undefined
+}
+
+type StreamProps = {
+  initialState: StreamState
+  baseURL: string
+  subscribed: string[]
+  bind: (api: { update: (next: StreamState) => void; exit: () => void; onInterrupt: (fn: () => void) => void }) => void
+}
+
+const StreamView: React.FC<StreamProps> = ({ initialState, baseURL, subscribed, bind }) => {
+  const [state, setState] = useState<StreamState>(initialState)
+  const { exit } = useApp()
+  const interruptRef = useRef<(() => void) | undefined>(undefined)
+
+  useEffect(() => {
+    bind({
+      update: setState,
+      exit: () => exit(),
+      onInterrupt: fn => { interruptRef.current = fn },
+    })
+  }, [bind, exit])
+
+  useInput((input, key) => {
+    if (key.ctrl && input === 'c') {
+      interruptRef.current?.()
+    }
+  })
+
+  return (
+    <Box flexDirection="column">
+      <StreamHeader subscribed={subscribed} baseURL={baseURL} connected={state.connected} />
+      <Static items={state.events.map((event, index) => ({ event, index: index + 1 }))}>
+        {({ event, index }) => <StreamEventLine event={event} index={index} key={index} />}
+      </Static>
+      {!state.connected && state.status && (
+        <Box>
+          <Text color={theme.warn}><Spinner type="dots" /></Text>
+          <Text color={theme.muted}>  {state.status}</Text>
+        </Box>
+      )}
+    </Box>
+  )
+}
+
+export function renderStream(opts: { baseURL: string; subscribed: string[] }): StreamController {
+  const initial: StreamState = { events: [], connected: false, status: 'connecting' }
+  let current = initial
+  let api: { update: (next: StreamState) => void; exit: () => void; onInterrupt: (fn: () => void) => void } | undefined
+  const interruptHandlers: Array<() => void> = []
+
+  const setState = (next: StreamState): void => {
+    current = next
+    api?.update(next)
+  }
+
+  const instance = inkRender(
+    <StreamView
+      initialState={initial}
+      baseURL={opts.baseURL}
+      subscribed={opts.subscribed}
+      bind={hooks => {
+        api = hooks
+        hooks.onInterrupt(() => {
+          for (const fn of interruptHandlers) fn()
+        })
+      }}
+    />,
+    { exitOnCtrlC: false, patchConsole: false },
+  )
+
+  return {
+    push(event) {
+      setState({ ...current, events: [...current.events, event] })
+    },
+    setConnected(connected) {
+      setState({ ...current, connected, status: connected ? undefined : current.status })
+    },
+    setStatus(status) {
+      setState({ ...current, status })
+    },
+    async close() {
+      api?.exit()
+      await instance.waitUntilExit().catch(() => undefined)
+    },
+    get done() {
+      return instance.waitUntilExit().then(() => undefined)
+    },
+  }
+}
+
+export type { Suggestion, StreamEvent }
diff --git a/src/lib/ink/spinner.tsx b/src/lib/ink/spinner.tsx
new file mode 100644
index 0000000..0956e26
--- /dev/null
+++ b/src/lib/ink/spinner.tsx
@@ -0,0 +1,121 @@
+import React, { useEffect, useState } from 'react'
+import { Box, render, Text, useApp } from 'ink'
+import Spinner from 'ink-spinner'
+import { glyphs, theme } from './theme.js'
+
+type State =
+  | { kind: 'spinning'; label: string }
+  | { kind: 'succeed'; label: string }
+  | { kind: 'fail'; label: string }
+
+const externalListeners = new Map<symbol, (state: State) => void>()
+
+type SpinnerLineProps = {
+  id: symbol
+  initial: State
+}
+
+const SpinnerLine: React.FC<SpinnerLineProps> = ({ id, initial }) => {
+  const [state, setState] = useState<State>(initial)
+  const { exit } = useApp()
+
+  useEffect(() => {
+    externalListeners.set(id, value => {
+      setState(value)
+      if (value.kind !== 'spinning') {
+        setTimeout(() => exit(), 0)
+      }
+    })
+    return () => { externalListeners.delete(id) }
+  }, [id, exit])
+
+  if (state.kind === 'spinning') {
+    return (
+      <Box>
+        <Text color={theme.primary}><Spinner type="dots" /></Text>
+        <Text color={theme.muted}> {state.label}</Text>
+      </Box>
+    )
+  }
+  if (state.kind === 'succeed') {
+    return (
+      <Box>
+        <Text color={theme.primary}>{glyphs.check}</Text>
+        <Text color={theme.text}> {state.label}</Text>
+      </Box>
+    )
+  }
+  return (
+    <Box>
+      <Text color={theme.danger}>{glyphs.cross}</Text>
+      <Text color={theme.text}> {state.label}</Text>
+    </Box>
+  )
+}
+
+export type SpinnerHandle = {
+  update(label: string): void
+  succeed(label?: string): Promise<void>
+  fail(label?: string): Promise<void>
+  stop(): Promise<void>
+}
+
+export function createInkSpinner(initialLabel: string, stream: NodeJS.WriteStream = process.stderr): SpinnerHandle {
+  const id = Symbol('spinner')
+  let currentLabel = initialLabel
+  let finished = false
+
+  const instance = render(
+    <SpinnerLine id={id} initial={{ kind: 'spinning', label: initialLabel }} />,
+    { stdout: stream as unknown as NodeJS.WriteStream, exitOnCtrlC: false, patchConsole: false },
+  )
+
+  const finish = (state: State): Promise<void> => {
+    if (finished) return Promise.resolve()
+    finished = true
+    const listener = externalListeners.get(id)
+    if (listener) listener(state)
+    else instance.unmount()
+    return instance.waitUntilExit().then(() => undefined).catch(() => undefined)
+  }
+
+  return {
+    update(label) {
+      if (finished) return
+      currentLabel = label
+      const listener = externalListeners.get(id)
+      listener?.({ kind: 'spinning', label })
+    },
+    succeed(label) {
+      return finish({ kind: 'succeed', label: label ?? currentLabel })
+    },
+    fail(label) {
+      return finish({ kind: 'fail', label: label ?? currentLabel })
+    },
+    stop() {
+      if (finished) return Promise.resolve()
+      finished = true
+      instance.unmount()
+      return instance.waitUntilExit().then(() => undefined).catch(() => undefined)
+    },
+  }
+}
+
+export async function withInkSpinner<T>(
+  label: string,
+  fn: () => Promise<T>,
+  options?: { done?: (value: T) => string | undefined; stream?: NodeJS.WriteStream },
+): Promise<T> {
+  const stream = options?.stream ?? process.stderr
+  const spinner = createInkSpinner(label, stream)
+  try {
+    const value = await fn()
+    const doneLabel = options?.done?.(value)
+    if (doneLabel) await spinner.succeed(doneLabel)
+    else await spinner.stop()
+    return value
+  } catch (error) {
+    await spinner.fail(label)
+    throw error
+  }
+}
diff --git a/src/lib/ink/theme.ts b/src/lib/ink/theme.ts
new file mode 100644
index 0000000..32986f4
--- /dev/null
+++ b/src/lib/ink/theme.ts
@@ -0,0 +1,107 @@
+// Beeper Desktop dark-theme palette → Ink hex strings.
+// Mirrors src/renderer/scss/tokens/colors{,_dark}.scss in the desktop app.
+export const theme = {
+  // Brand / accent
+  primary: '#2561fb',
+  primaryDim: '#1b43aa',
+  primaryGlow: '#5a86ff',
+  link: '#5cadff',
+
+  // Text
+  text: '#ededed',          // --color-text-neutrals (dark)
+  muted: '#adadad',         // --color-text-neutrals-weak
+  subtle: '#7e7e7e',        // --color-text-neutrals-subtle
+  hairline: '#343434',      // --color-border-neutrals
+
+  // Surface (only used when we explicitly fill — Ink defaults to the user's term bg)
+  surface: '#000000',
+  surfaceAlt: '#1c1c1c',
+  surfaceHover: '#232323',
+
+  // Semantic
+  mine: '#4cc38a',          // --color-text-success (dark)
+  online: '#1ec843',
+  warn: '#f6ce46',          // --color-pin
+  warnAlt: '#f1a10d',
+  danger: '#ff6369',        // --color-text-error (dark)
+  magenta: '#912ce1',       // --color-mute (dark)
+  cyan: '#00c2d7',
+
+  // Highlights
+  mention: '#5a86ff',
+  draft: '#f6ce46',
+} as const
+
+// Per-bridge "iconBackground" tints from beeper/desktop bundled-platforms/bridges/*/info.ts.
+// Used to tint the rail/badge on chat & account rows so a glance reveals the network.
+const bridgeTint: Record<string, string> = {
+  imessage: '#19BA3B',
+  imessagecloud: '#19BA3B',
+  imessagego: '#19BA3B',
+  androidsms: '#19BA3B',
+  whatsapp: '#48C95F',
+  telegram: '#2EA4DB',
+  signal: '#3542FF',
+  discord: '#5865F2',
+  linkedin: '#086CE1',
+  twitter: '#202124',
+  x: '#202124',
+  bluesky: '#549B57',
+  beeper: '#0D4FFB',
+  beeperai: '#0D4FFB',
+  ai: '#0D4FFB',
+  instagram: '#d833ca',
+  facebook: '#0d4ffb',
+  messenger: '#0d4ffb',
+  googlechat: '#1ab5a2',
+  googlevoice: '#0eb3ef',
+  googlemessages: '#19ba3b',
+  slack: '#9745ea',
+  matrix: '#0eb3ef',
+}
+
+export function bridgeColor(network: string | undefined | null): string | undefined {
+  if (!network) return undefined
+  const key = String(network).toLowerCase().replace(/[^a-z0-9]/g, '')
+  return bridgeTint[key]
+}
+
+// Group-chat sender name palette (8-color rotation) from the desktop dark theme.
+const groupSenderPalette = [
+  '#63c174', '#f1a10d', '#f76190', '#bf7af0',
+  '#00c2d7', '#f65cb6', '#849dff', '#0ac5b3',
+] as const
+
+export function senderColor(id: string | undefined | null): string {
+  if (!id) return theme.text
+  let hash = 0
+  for (let i = 0; i < id.length; i++) hash = ((hash << 5) - hash + id.charCodeAt(i)) | 0
+  const palette = groupSenderPalette
+  return palette[Math.abs(hash) % palette.length]!
+}
+
+// Glyphs — every visual cue we use sits in this map so a single audit covers them.
+export const glyphs = {
+  rail: '▎',            // narrow left-edge bar; replaces avatars
+  arrow: '›',
+  arrowR: '→',
+  arrowL: '←',
+  check: '✓',
+  cross: '✗',
+  dot: '●',
+  ring: '○',
+  pin: '★',
+  mute: '◐',
+  archive: '◇',
+  reaction: '♥',
+  attachment: '📎',
+  reply: '↳',
+  edited: '✎',
+  bullet: '·',
+  lowPriority: '◌',
+  mention: '@',
+  draft: '✎',
+  unread: '●',
+  spinner: '◇',
+  hairline: '─',
+} as const
diff --git a/src/lib/manifest.ts b/src/lib/manifest.ts
new file mode 100644
index 0000000..ec49262
--- /dev/null
+++ b/src/lib/manifest.ts
@@ -0,0 +1,86 @@
+import { apiCopy } from './copy.js'
+
+export const commandManifest = [
+  { command: 'accounts', description: apiCopy.accounts.list },
+  { command: 'accounts add', description: 'Add a Beeper account' },
+  { command: 'api get', description: 'Make an authenticated raw GET request' },
+  { command: 'api post', description: 'Make an authenticated raw POST request' },
+  { command: 'app e2ee recovery-code mark-backed-up', description: 'Mark the recovery key as saved' },
+  { command: 'app e2ee recovery-code reset begin', description: 'Create a new recovery key' },
+  { command: 'app e2ee recovery-code reset confirm', description: 'Confirm a newly created recovery key' },
+  { command: 'app e2ee recovery-code verify', description: 'Unlock encrypted messages with a recovery key' },
+  { command: 'app e2ee verification accept', description: 'Accept a device verification request' },
+  { command: 'app e2ee verification cancel', description: 'Cancel device verification' },
+  { command: 'app e2ee verification qr confirm-scanned', description: 'Confirm another device scanned this QR code' },
+  { command: 'app e2ee verification qr scan', description: 'Submit a scanned verification QR payload' },
+  { command: 'app e2ee verification sas confirm', description: 'Confirm matching emoji verification' },
+  { command: 'app e2ee verification sas start', description: 'Start emoji verification' },
+  { command: 'app e2ee verification start', description: 'Start device verification' },
+  { command: 'app status', description: 'Show Beeper app login and encrypted messaging state' },
+  { command: 'archive', description: apiCopy.chats.archive },
+  { command: 'assets download', description: apiCopy.assets.download },
+  { command: 'assets upload', description: apiCopy.assets.upload },
+  { command: 'auth login', description: 'Authenticate with local Beeper Desktop' },
+  { command: 'auth logout', description: 'Remove local credentials' },
+  { command: 'auth status', description: 'Show local auth state' },
+  { command: 'avatar', description: 'Set or clear a group chat avatar' },
+  { command: 'chat', description: apiCopy.chats.retrieve },
+  { command: 'chat open', description: 'Alias for focus' },
+  { command: 'chats', description: apiCopy.chats.list },
+  { command: 'chats search', description: apiCopy.chats.search },
+  { command: 'clear-draft', description: 'Clear a chat draft' },
+  { command: 'commands', description: 'Print the command manifest' },
+  { command: 'config get', description: 'Print CLI configuration' },
+  { command: 'config path', description: 'Print the config file path' },
+  { command: 'config reset', description: 'Reset CLI configuration' },
+  { command: 'config set', description: 'Set CLI configuration' },
+  { command: 'contacts list', description: apiCopy.contacts.list },
+  { command: 'contacts search', description: apiCopy.contacts.search },
+  { command: 'create-chat', description: apiCopy.chats.create },
+  { command: 'current-user', description: 'Show the OAuth userinfo response' },
+  { command: 'delete-message', description: apiCopy.messages.delete },
+  { command: 'description', description: 'Set or clear a group chat description' },
+  { command: 'doctor', description: 'Check Desktop API readiness' },
+  { command: 'draft', description: 'Set a chat draft' },
+  { command: 'edit', description: apiCopy.messages.update },
+  { command: 'export', description: 'Export accounts, chats, messages, Markdown transcripts, and attachments' },
+  { command: 'focus', description: 'Focus Beeper Desktop or one chat' },
+  { command: 'inbox', description: 'Move a chat to the primary inbox' },
+  { command: 'llm', description: 'Print compact CLI help for agents' },
+  { command: 'login', description: 'Authenticate with Beeper Desktop' },
+  { command: 'logout', description: 'Remove local credentials' },
+  { command: 'low-priority', description: 'Move a chat to Low Priority' },
+  { command: 'message', description: apiCopy.messages.retrieve },
+  { command: 'message-expiry', description: 'Set or clear disappearing-message expiry' },
+  { command: 'mark-read', description: 'Alias for read' },
+  { command: 'mark-unread', description: 'Alias for unread' },
+  { command: 'messages', description: apiCopy.messages.list },
+  { command: 'messages search', description: apiCopy.messages.search },
+  { command: 'mute', description: 'Mute a chat' },
+  { command: 'notify-anyway', description: apiCopy.chats.notifyAnyway },
+  { command: 'pin', description: 'Pin a chat' },
+  { command: 'react', description: apiCopy.reactions.add },
+  { command: 'read', description: apiCopy.chats.markRead },
+  { command: 'remind', description: apiCopy.reminders.create },
+  { command: 'reply', description: apiCopy.messages.send },
+  { command: 'reply-file', description: apiCopy.messages.send },
+  { command: 'rpc', description: 'Run JSONL command RPC over stdin/stdout' },
+  { command: 'search', description: 'Search chats and messages' },
+  { command: 'send', description: apiCopy.messages.send },
+  { command: 'send-file', description: apiCopy.messages.send },
+  { command: 'shell', description: 'Run an interactive Beeper CLI shell' },
+  { command: 'start-chat', description: apiCopy.chats.start },
+  { command: 'status', description: 'Show Desktop API server info' },
+  { command: 'tail', description: 'Alias for watch' },
+  { command: 'thread', description: 'Alias for chat' },
+  { command: 'threads', description: 'Alias for chats' },
+  { command: 'title', description: 'Set a custom chat title' },
+  { command: 'unarchive', description: apiCopy.chats.archive },
+  { command: 'unmute', description: 'Unmute a chat' },
+  { command: 'unpin', description: 'Unpin a chat' },
+  { command: 'unreact', description: apiCopy.reactions.delete },
+  { command: 'unread', description: apiCopy.chats.markUnread },
+  { command: 'unremind', description: apiCopy.reminders.delete },
+  { command: 'watch', description: 'Stream Desktop API WebSocket events' },
+  { command: 'whoami', description: 'Alias for current-user' },
+]
diff --git a/src/lib/oauth.ts b/src/lib/oauth.ts
new file mode 100644
index 0000000..d97dad8
--- /dev/null
+++ b/src/lib/oauth.ts
@@ -0,0 +1,166 @@
+import { createServer } from 'node:http'
+import { AddressInfo } from 'node:net'
+import { spawn } from 'node:child_process'
+import { createPKCEPair, createState } from './pkce.js'
+import { updateConfig } from './config.js'
+
+export type OAuthLoginOptions = {
+  baseURL: string
+  clientName: string
+  openBrowser: boolean
+  save?: boolean
+  scope: string
+  timeoutMs?: number
+}
+
+type RegisterResponse = {
+  authorization_endpoint?: string
+  client_id: string
+  token_endpoint?: string
+}
+
+type TokenResponse = {
+  access_token: string
+  expires_in?: number
+  scope?: string
+  token_type: 'Bearer'
+}
+
+export async function loginWithPKCE(options: OAuthLoginOptions): Promise<TokenResponse & { clientID: string }> {
+  const callback = await createCallbackServer(options.timeoutMs ?? 120_000)
+  try {
+    const redirectURI = `http://127.0.0.1:${callback.port}/callback`
+    const registered = await registerClient(options.baseURL, options.clientName, redirectURI, options.scope)
+    const pkce = createPKCEPair()
+    const state = createState()
+    const authorizeURL = new URL(registered.authorization_endpoint ?? '/oauth/authorize', options.baseURL)
+    authorizeURL.searchParams.set('client_id', registered.client_id)
+    authorizeURL.searchParams.set('redirect_uri', redirectURI)
+    authorizeURL.searchParams.set('response_type', 'code')
+    authorizeURL.searchParams.set('scope', options.scope)
+    authorizeURL.searchParams.set('state', state)
+    authorizeURL.searchParams.set('code_challenge', pkce.codeChallenge)
+    authorizeURL.searchParams.set('code_challenge_method', 'S256')
+
+    if (options.openBrowser) openExternal(authorizeURL.toString())
+    else process.stderr.write(`Open this URL to authenticate:\n${authorizeURL.toString()}\n`)
+
+    const result = await callback.waitForCode
+    if (result.state !== state) throw new Error('OAuth state mismatch.')
+    if (result.error) throw new Error(`OAuth authorization failed: ${result.error}`)
+    if (!result.code) throw new Error('OAuth callback did not include an authorization code.')
+
+    const token = await exchangeToken(
+      registered.token_endpoint ?? new URL('/oauth/token', options.baseURL).toString(),
+      registered.client_id,
+      result.code,
+      pkce.codeVerifier,
+    )
+
+    if (options.save !== false) {
+      await updateConfig(config => ({
+        ...config,
+        baseURL: options.baseURL,
+        auth: {
+          accessToken: token.access_token,
+          clientID: registered.client_id,
+          expiresAt: token.expires_in ? new Date(Date.now() + token.expires_in * 1000).toISOString() : undefined,
+          scope: token.scope,
+          tokenType: token.token_type,
+        },
+      }))
+    }
+
+    return { ...token, clientID: registered.client_id }
+  } finally {
+    await callback.close()
+  }
+}
+
+async function registerClient(baseURL: string, clientName: string, redirectURI: string, scope: string): Promise<RegisterResponse> {
+  const response = await fetch(new URL('/oauth/register', baseURL), {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      client_name: clientName,
+      grant_types: ['authorization_code'],
+      response_types: ['code'],
+      redirect_uris: [redirectURI],
+      scope,
+      token_endpoint_auth_method: 'none',
+    }),
+  })
+  if (!response.ok) throw new Error(`OAuth client registration failed: ${response.status} ${await response.text()}`)
+  return response.json() as Promise<RegisterResponse>
+}
+
+async function exchangeToken(tokenEndpoint: string, clientID: string, code: string, codeVerifier: string): Promise<TokenResponse> {
+  const body = new URLSearchParams({
+    grant_type: 'authorization_code',
+    client_id: clientID,
+    code,
+    code_verifier: codeVerifier,
+  })
+  const response = await fetch(tokenEndpoint, {
+    method: 'POST',
+    headers: { 'content-type': 'application/x-www-form-urlencoded' },
+    body,
+  })
+  if (!response.ok) throw new Error(`OAuth token exchange failed: ${response.status} ${await response.text()}`)
+  return response.json() as Promise<TokenResponse>
+}
+
+function openExternal(url: string): void {
+  const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open'
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url]
+  const child = spawn(command, args, { detached: true, stdio: 'ignore' })
+  child.unref()
+}
+
+function createCallbackServer(timeoutMs: number): Promise<{
+  close: () => Promise<void>
+  port: number
+  waitForCode: Promise<{ code?: string; error?: string; state?: string }>
+}> {
+  return new Promise((resolve, reject) => {
+    let settle!: (value: { code?: string; error?: string; state?: string }) => void
+    let fail!: (error: Error) => void
+    const waitForCode = new Promise<{ code?: string; error?: string; state?: string }>((res, rej) => {
+      settle = res
+      fail = rej
+    })
+
+    const server = createServer((req, res) => {
+      try {
+        const url = new URL(req.url ?? '/', 'http://127.0.0.1')
+        if (url.pathname !== '/callback') {
+          res.writeHead(404).end('Not found')
+          return
+        }
+        const code = url.searchParams.get('code') ?? undefined
+        const error = url.searchParams.get('error') ?? undefined
+        const state = url.searchParams.get('state') ?? undefined
+        res.writeHead(200, { 'content-type': 'text/html' })
+        res.end('<!doctype html><title>Beeper CLI</title><p>You can close this tab and return to the terminal.</p>')
+        settle({ code, error, state })
+      } catch (error) {
+        fail(error instanceof Error ? error : new Error(String(error)))
+      }
+    })
+
+    const timeout = setTimeout(() => fail(new Error('Timed out waiting for OAuth callback.')), timeoutMs)
+    server.on('error', reject)
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address() as AddressInfo
+      resolve({
+        close: () =>
+          new Promise(closeResolve => {
+            clearTimeout(timeout)
+            server.close(() => closeResolve())
+          }),
+        port: address.port,
+        waitForCode,
+      })
+    })
+  })
+}
diff --git a/src/lib/output.ts b/src/lib/output.ts
new file mode 100644
index 0000000..473750d
--- /dev/null
+++ b/src/lib/output.ts
@@ -0,0 +1,120 @@
+import type { StreamController, Suggestion } from './ink/render.js'
+
+export type OutputFormat = 'human' | 'json' | 'jsonl'
+type RecordValue = Record<string, unknown>
+
+const writeJSON = (value: unknown, format: 'json' | 'jsonl'): void => {
+  process.stdout.write(`${JSON.stringify(value, null, format === 'json' ? 2 : 0)}\n`)
+}
+
+const loadInk = () => import('./ink/render.js')
+
+export async function printData(value: unknown, format: OutputFormat): Promise<void> {
+  if (format === 'json') {
+    writeJSON(value, 'json')
+    return
+  }
+  if (format === 'jsonl') {
+    if (Array.isArray(value)) {
+      for (const item of value) process.stdout.write(`${JSON.stringify(item)}\n`)
+      return
+    }
+    process.stdout.write(`${JSON.stringify(value)}\n`)
+    return
+  }
+  const { renderValue } = await loadInk()
+  await renderValue(value)
+}
+
+export async function printList(
+  value: unknown[],
+  format: OutputFormat,
+  empty: { title: string; subtitle?: string; suggestions?: Suggestion[] },
+): Promise<void> {
+  if (format === 'json') {
+    writeJSON(value, 'json')
+    return
+  }
+  if (format === 'jsonl') {
+    for (const item of value) process.stdout.write(`${JSON.stringify(item)}\n`)
+    return
+  }
+  const { renderList } = await loadInk()
+  await renderList(value as RecordValue[], empty)
+}
+
+export async function collectPage<T>(iterable: AsyncIterable<T>, limit?: number): Promise<T[]> {
+  const items: T[] = []
+  for await (const item of iterable) {
+    items.push(item)
+    if (limit && items.length >= limit) break
+  }
+  return items
+}
+
+export function printIDs(values: unknown[]): void {
+  for (const value of values) {
+    if (!value || typeof value !== 'object') continue
+    const record = value as Record<string, unknown>
+    const id = record.id ?? record.chatID ?? record.messageID
+    if (id) process.stdout.write(`${String(id)}\n`)
+  }
+}
+
+export async function emptyState(opts: { title: string; subtitle?: string; suggestions?: Suggestion[] }): Promise<void> {
+  const { renderEmptyState } = await loadInk()
+  await renderEmptyState(opts)
+}
+
+export async function printSuccess(
+  opts: { message: string; detail?: string; entity?: unknown; data?: Record<string, unknown> },
+  format: OutputFormat,
+): Promise<void> {
+  if (format === 'json' || format === 'jsonl') {
+    writeJSON({ ok: true, message: opts.message, ...(opts.data ?? {}) }, format)
+    return
+  }
+  const { renderSuccess } = await loadInk()
+  await renderSuccess(opts)
+}
+
+export async function printFailure(
+  opts: { message: string; detail?: string; data?: Record<string, unknown> },
+  format: OutputFormat,
+): Promise<void> {
+  if (format === 'json' || format === 'jsonl') {
+    writeJSON({ ok: false, message: opts.message, ...(opts.data ?? {}) }, format)
+    return
+  }
+  const { renderFailure } = await loadInk()
+  await renderFailure(opts)
+}
+
+export async function printConfig(data: Record<string, unknown>, format: OutputFormat): Promise<void> {
+  if (format === 'json' || format === 'jsonl') {
+    writeJSON(data, format)
+    return
+  }
+  const { renderConfig } = await loadInk()
+  await renderConfig(data)
+}
+
+export async function printCommands(
+  items: Array<{ command: string; description: string; group?: string }>,
+  format: OutputFormat,
+  opts?: { title?: string; intro?: string[] },
+): Promise<void> {
+  if (format === 'json' || format === 'jsonl') {
+    writeJSON(items, format)
+    return
+  }
+  const { renderCommands } = await loadInk()
+  await renderCommands(items, opts)
+}
+
+export async function startStream(opts: { baseURL: string; subscribed: string[] }): Promise<StreamController> {
+  const { renderStream } = await loadInk()
+  return renderStream(opts)
+}
+
+export type { Suggestion } from './ink/render.js'
diff --git a/src/lib/pkce.ts b/src/lib/pkce.ts
new file mode 100644
index 0000000..34cac24
--- /dev/null
+++ b/src/lib/pkce.ts
@@ -0,0 +1,16 @@
+import { createHash, randomBytes } from 'node:crypto'
+
+export type PKCEPair = {
+  codeChallenge: string
+  codeVerifier: string
+}
+
+export function createPKCEPair(): PKCEPair {
+  const codeVerifier = randomBytes(64).toString('base64url')
+  const codeChallenge = createHash('sha256').update(codeVerifier).digest('base64url')
+  return { codeChallenge, codeVerifier }
+}
+
+export function createState(): string {
+  return randomBytes(24).toString('base64url')
+}
diff --git a/src/lib/resolve.ts b/src/lib/resolve.ts
new file mode 100644
index 0000000..a53102a
--- /dev/null
+++ b/src/lib/resolve.ts
@@ -0,0 +1,144 @@
+type AnyRecord = Record<string, any>
+
+export type AccountResolutionOptions = {
+  allowMultiplePerInput?: boolean
+}
+
+export type ChatResolutionOptions = {
+  accountIDs?: string[]
+  pick?: number
+}
+
+export async function resolveAccountIDs(
+  client: any,
+  inputs?: string[],
+  options: AccountResolutionOptions = {},
+): Promise<string[] | undefined> {
+  if (!inputs?.length) return undefined
+
+  const accounts = await client.accounts.list() as AnyRecord[]
+  const resolved: string[] = []
+  for (const input of inputs) {
+    const matches = matchAccounts(accounts, input)
+    if (matches.length === 0) throw new Error(`No account matches "${input}"`)
+    if (matches.length > 1 && !options.allowMultiplePerInput) {
+      throw new Error(formatAmbiguous(`account "${input}"`, matches.map(formatAccount)))
+    }
+    resolved.push(...matches.map(account => String(account.accountID)))
+  }
+
+  return Array.from(new Set(resolved))
+}
+
+export async function resolveAccountID(client: any, input: string): Promise<string> {
+  const [accountID] = await resolveAccountIDs(client, [input]) ?? []
+  if (!accountID) throw new Error(`No account matches "${input}"`)
+  return accountID
+}
+
+export async function listAccountIDs(client: any): Promise<string[]> {
+  const accounts = await client.accounts.list() as AnyRecord[]
+  return accounts.map(account => String(account.accountID)).filter(Boolean)
+}
+
+export async function resolveChatID(client: any, input: string, options: ChatResolutionOptions = {}): Promise<string> {
+  const exact = await retrieveChat(client, input)
+  if (exact) return exact.id
+
+  const candidates = await collect<AnyRecord>(client.chats.search({
+    accountIDs: options.accountIDs,
+    query: input,
+    scope: 'titles',
+  }), 10)
+
+  const normalizedInput = normalize(input)
+  const exactMatches = candidates.filter(chat =>
+    normalize(chat.id) === normalizedInput ||
+    normalize(chat.localChatID) === normalizedInput ||
+    normalize(chat.title) === normalizedInput
+  )
+  const matches = exactMatches.length ? exactMatches : candidates
+  if (matches.length === 0) return input
+  if (matches.length === 1) return String(matches[0]!.id)
+
+  if (options.pick) {
+    const selected = matches[options.pick - 1]
+    if (!selected) throw new Error(`--pick ${options.pick} is outside the ${matches.length} matching chats`)
+    return String(selected.id)
+  }
+
+  throw new Error(formatAmbiguous(`chat "${input}"`, matches.map(formatChat)))
+}
+
+function matchAccounts(accounts: AnyRecord[], input: string): AnyRecord[] {
+  const normalizedInput = normalize(input)
+  const exact = accounts.filter(account =>
+    normalize(account.accountID) === normalizedInput ||
+    normalize(account.network) === normalizedInput ||
+    normalize(account.bridge?.type) === normalizedInput ||
+    normalize(account.bridge?.id) === normalizedInput ||
+    normalize(account.user?.id) === normalizedInput ||
+    normalize(account.user?.username) === normalizedInput ||
+    normalize(account.user?.displayName) === normalizedInput ||
+    normalize(account.user?.name) === normalizedInput ||
+    normalize(account.user?.email) === normalizedInput
+  )
+  if (exact.length) return exact
+
+  return accounts.filter(account =>
+    includesNormalized(account.accountID, normalizedInput) ||
+    includesNormalized(account.network, normalizedInput) ||
+    includesNormalized(account.bridge?.type, normalizedInput) ||
+    includesNormalized(account.bridge?.id, normalizedInput) ||
+    includesNormalized(account.user?.displayName, normalizedInput) ||
+    includesNormalized(account.user?.name, normalizedInput)
+  )
+}
+
+async function retrieveChat(client: any, input: string): Promise<AnyRecord | undefined> {
+  try {
+    return await client.chats.retrieve(input, { maxParticipants: 0 })
+  } catch {
+    return undefined
+  }
+}
+
+async function collect<T>(iterable: AsyncIterable<T>, limit: number): Promise<T[]> {
+  const items: T[] = []
+  for await (const item of iterable) {
+    items.push(item)
+    if (items.length >= limit) break
+  }
+  return items
+}
+
+function normalize(value: unknown): string {
+  return String(value ?? '').trim().toLowerCase().replace(/[\s._-]+/g, '')
+}
+
+function includesNormalized(value: unknown, normalizedInput: string): boolean {
+  return normalize(value).includes(normalizedInput)
+}
+
+function formatAmbiguous(label: string, choices: string[]): string {
+  return `Ambiguous ${label}. Use an exact ID or --pick N:\n${choices.map((choice, index) => `  ${index + 1}. ${choice}`).join('\n')}`
+}
+
+function formatAccount(account: AnyRecord): string {
+  const network = account.network ? ` ${account.network}` : ''
+  const bridge = account.bridge?.type ? ` ${account.bridge.type}` : ''
+  const user = account.user?.displayName || account.user?.name || account.user?.username || account.user?.id || ''
+  return `${account.accountID}${network}${bridge}${user ? ` ${user}` : ''}`
+}
+
+function formatChat(chat: AnyRecord): string {
+  const network = chat.network ? ` ${chat.network}` : ''
+  return `${chat.id}${network} ${chat.title ?? ''}`.trim()
+}
+
+export function userQueryFromInput(input: string): AnyRecord {
+  const trimmed = input.trim()
+  if (trimmed.includes('@')) return { email: trimmed, username: trimmed }
+  if (/^\+?[\d\s().-]{5,}$/.test(trimmed)) return { phoneNumber: trimmed }
+  return { fullName: trimmed, username: trimmed, id: trimmed }
+}
diff --git a/src/lib/runner.ts b/src/lib/runner.ts
new file mode 100644
index 0000000..f6d2341
--- /dev/null
+++ b/src/lib/runner.ts
@@ -0,0 +1,38 @@
+import { spawn } from 'node:child_process'
+
+export type RunResult = {
+  code: number | null
+  signal: NodeJS.Signals | null
+  stdout: string
+  stderr: string
+}
+
+export async function runCli(args: string[], options: { inherit?: boolean } = {}): Promise<RunResult> {
+  const child = spawn(process.execPath, [process.argv[1]!, ...args], {
+    env: process.env,
+    stdio: options.inherit ? 'inherit' : ['ignore', 'pipe', 'pipe'],
+  })
+
+  if (options.inherit) {
+    return new Promise((resolve, reject) => {
+      child.on('error', reject)
+      child.on('close', (code, signal) => resolve({ code, signal, stdout: '', stderr: '' }))
+    })
+  }
+
+  let stdout = ''
+  let stderr = ''
+  child.stdout?.setEncoding('utf8')
+  child.stderr?.setEncoding('utf8')
+  child.stdout?.on('data', chunk => {
+    stdout += chunk
+  })
+  child.stderr?.on('data', chunk => {
+    stderr += chunk
+  })
+
+  return new Promise((resolve, reject) => {
+    child.on('error', reject)
+    child.on('close', (code, signal) => resolve({ code, signal, stdout, stderr }))
+  })
+}
diff --git a/src/lib/ui.ts b/src/lib/ui.ts
new file mode 100644
index 0000000..5d82c93
--- /dev/null
+++ b/src/lib/ui.ts
@@ -0,0 +1,3 @@
+export { createInkSpinner as createSpinner, withInkSpinner as withSpinner, type SpinnerHandle as Spinner } from './ink/spinner.js'
+export { renderEmptyState as emptyState } from './ink/render.js'
+export type { Suggestion } from './ink/render.js'
diff --git a/src/lib/wait.ts b/src/lib/wait.ts
new file mode 100644
index 0000000..12d0ad5
--- /dev/null
+++ b/src/lib/wait.ts
@@ -0,0 +1,24 @@
+import { setTimeout as sleep } from 'node:timers/promises'
+
+export type WaitOptions = {
+  intervalMs?: number
+  timeoutMs?: number
+}
+
+export async function waitForMessage(client: any, chatID: string, pendingMessageID: string, options: WaitOptions = {}) {
+  const started = Date.now()
+  const timeoutMs = options.timeoutMs ?? 30_000
+  const intervalMs = options.intervalMs ?? 750
+  let lastError: unknown
+
+  while (Date.now() - started < timeoutMs) {
+    try {
+      return await client.messages.retrieve(pendingMessageID, { chatID })
+    } catch (error) {
+      lastError = error
+      await sleep(intervalMs)
+    }
+  }
+
+  throw new Error(`Timed out waiting for ${pendingMessageID}${lastError instanceof Error ? `: ${lastError.message}` : ''}`)
+}
diff --git a/test/cli-smoke.mjs b/test/cli-smoke.mjs
new file mode 100644
index 0000000..3001a5f
--- /dev/null
+++ b/test/cli-smoke.mjs
@@ -0,0 +1,367 @@
+import assert from 'node:assert/strict'
+import { spawn, spawnSync } from 'node:child_process'
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { createServer } from 'node:http'
+import { join, relative } from 'node:path'
+import { tmpdir } from 'node:os'
+import { fileURLToPath } from 'node:url'
+import { commandManifest } from '../dist/lib/manifest.js'
+import { exportBeeperData } from '../dist/lib/export/index.js'
+import { ensureDesktopToken, findLocalDesktop } from '../dist/lib/desktop-auth.js'
+import { resolveAccountID, resolveAccountIDs, resolveChatID } from '../dist/lib/resolve.js'
+
+const root = fileURLToPath(new URL('..', import.meta.url))
+const run = (...args) => spawnSync(process.execPath, ['./bin/run.js', ...args], {
+  cwd: root,
+  encoding: 'utf8',
+  env: {
+    ...process.env,
+    BEEPER_CLI_CONFIG_DIR: '/tmp/beeper-cli-test',
+  },
+})
+
+const ok = (...args) => {
+  const result = run(...args)
+  assert.equal(result.status, 0, `${args.join(' ')} failed\nSTDOUT:\n${result.stdout}\nSTDERR:\n${result.stderr}`)
+  return result.stdout
+}
+
+const commandFiles = listCommandFiles(join(root, 'src/commands'))
+const commandNames = commandFiles.map(file => fileToCommand(file)).sort()
+const manifestNames = commandManifest.map(item => item.command).sort()
+
+assert.deepEqual(manifestNames, commandNames, 'command manifest must match src/commands')
+assert.equal(new Set(manifestNames).size, manifestNames.length, 'command manifest must not contain duplicates')
+
+const help = ok('--help')
+assert.match(help, /\bchat\b/, 'help should expose canonical chat command')
+assert.match(help, /\bchats\b/, 'help should expose canonical chats command')
+assert.match(help, /\bthread\b/, 'help should expose compatibility thread alias')
+assert.doesNotMatch(help, /\bfailed-sends\b|\bscheduled\b|\blocal\s+stats\b/, 'help must not expose stale local DB commands')
+
+for (const command of [
+  ['chat', '--help'],
+  ['chat', 'open', '--help'],
+  ['chats', '--help'],
+  ['thread', '--help'],
+  ['threads', '--help'],
+  ['tail', '--help'],
+  ['send-file', '--help'],
+  ['reply-file', '--help'],
+  ['watch', '--help'],
+  ['current-user', '--help'],
+  ['export', '--help'],
+  ['contacts', 'list', '--help'],
+  ['pin', '--help'],
+  ['unpin', '--help'],
+  ['low-priority', '--help'],
+  ['inbox', '--help'],
+  ['title', '--help'],
+  ['description', '--help'],
+  ['avatar', '--help'],
+  ['message-expiry', '--help'],
+  ['login', '--help'],
+  ['logout', '--help'],
+  ['whoami', '--help'],
+  ['config', 'get', '--help'],
+  ['config', 'set', '--help'],
+  ['config', 'reset', '--help'],
+  ['llm'],
+]) {
+  ok(...command)
+}
+
+assert.match(ok('send', '--help'), /--pick/, 'send should expose --pick for ambiguous chat names')
+assert.match(ok('send', '--help'), /--wait/, 'send should expose --wait')
+assert.match(ok('messages', '--help'), /--pick/, 'messages should expose --pick for ambiguous chat names')
+assert.match(ok('chats', '--help'), /--account=<value>\.\.\./, 'chats should accept account selectors')
+assert.match(ok('export', '--help'), /--out/, 'export should expose output directory selection')
+assert.match(ok('export', '--help'), /--no-attachments/, 'export should expose attachment control')
+assert.match(ok('login', '--help'), /--server-url/, 'login should expose --server-url')
+
+const commandsJSON = JSON.parse(ok('commands', '--json'))
+assert.equal(commandsJSON.length, commandManifest.length, 'commands --json should expose the full manifest')
+assert(commandsJSON.some(item => item.command === 'threads'), 'commands --json should include alias commands')
+assert(commandsJSON.some(item => item.command === 'chat'), 'commands --json should include canonical chat command')
+assert(commandsJSON.some(item => item.command === 'chat open'), 'commands --json should include chat open alias')
+assert(commandsJSON.some(item => item.command === 'tail'), 'commands --json should include tail alias')
+assert(commandsJSON.some(item => item.command === 'whoami'), 'commands --json should include whoami alias')
+assert(!commandsJSON.some(item => item.command.includes('serve')), 'commands --json must not include serve')
+assert(!commandsJSON.some(item => item.command.includes('base64')), 'commands --json must not include base64 asset variants')
+
+const configDir = '/tmp/beeper-cli-test-config'
+const configEnv = { ...process.env, BEEPER_CLI_CONFIG_DIR: configDir }
+let config = spawnSync(process.execPath, ['./bin/run.js', 'config', 'set', 'baseURL', 'http://127.0.0.1:23373'], {
+  cwd: root,
+  encoding: 'utf8',
+  env: configEnv,
+})
+assert.equal(config.status, 0, config.stderr)
+config = spawnSync(process.execPath, ['./bin/run.js', 'config', 'get', 'baseURL'], {
+  cwd: root,
+  encoding: 'utf8',
+  env: { ...configEnv, BEEPER_DESKTOP_BASE_URL: 'http://127.0.0.1:24444' },
+})
+assert.equal(config.status, 0, config.stderr)
+assert.match(config.stdout, /127\.0\.0\.1:24444/)
+config = spawnSync(process.execPath, ['./bin/run.js', 'config', 'reset'], {
+  cwd: root,
+  encoding: 'utf8',
+  env: configEnv,
+})
+assert.equal(config.status, 0, config.stderr)
+
+const rpc = spawnSync('printf', ['%s\n', '{"id":1,"command":"auth status --json"}'], {
+  encoding: 'utf8',
+  cwd: root,
+})
+assert.equal(rpc.status, 0, rpc.stderr)
+const rpcResult = spawnSync(process.execPath, ['./bin/run.js', 'rpc'], {
+  cwd: root,
+  encoding: 'utf8',
+  env: {
+    ...process.env,
+    BEEPER_CLI_CONFIG_DIR: '/tmp/beeper-cli-test',
+  },
+  input: rpc.stdout,
+})
+assert.equal(rpcResult.status, 0, rpcResult.stderr)
+const rpcLine = JSON.parse(rpcResult.stdout)
+assert.equal(rpcLine.id, 1)
+assert.equal(rpcLine.ok, true)
+assert.match(rpcLine.stdout, /"authenticated": false/)
+
+const shell = spawnSync(process.execPath, ['./bin/run.js', 'shell'], {
+  cwd: root,
+  encoding: 'utf8',
+  env: {
+    ...process.env,
+    BEEPER_CLI_CONFIG_DIR: '/tmp/beeper-cli-test',
+  },
+  input: 'auth status --json\nquit\n',
+})
+assert.equal(shell.status, 0, shell.stderr)
+assert.match(shell.stdout, /"authenticated": false/)
+
+const accountsOutput = await withMockAPI(async baseURL => {
+  const result = await runAsync(['./bin/run.js', 'accounts', '--base-url', baseURL], {
+    cwd: root,
+    env: {
+      ...process.env,
+      BEEPER_ACCESS_TOKEN: 'bdapi_test',
+      BEEPER_CLI_CONFIG_DIR: '/tmp/beeper-cli-accounts-test',
+    },
+  })
+  assert.equal(result.status, 0, result.stderr)
+  return result.stdout
+})
+assert.match(accountsOutput, /iMessage/)
+assert.doesNotMatch(accountsOutput, /No accounts connected/)
+
+const fakeClient = {
+  accounts: {
+    list: async () => [
+      { accountID: 'imessage-main', bridge: { id: 'local-imessage', type: 'imessage' }, network: 'iMessage', user: { displayName: 'Main' } },
+      { accountID: 'telegram-main', bridge: { id: 'telegramgo', type: 'telegram' }, network: 'Telegram', user: { displayName: 'Main' } },
+    ],
+  },
+  chats: {
+    retrieve: async id => {
+      if (id === '!exact:beeper.com' || id === 'local-family') return { id: '!family:beeper.com', localChatID: 'local-family', title: 'Family', network: 'iMessage' }
+      throw new Error('not found')
+    },
+    search: async function* ({ query }) {
+      const rows = [
+        { id: '!family:beeper.com', localChatID: 'local-family', title: 'Family', network: 'iMessage' },
+        { id: '!family-work:beeper.com', localChatID: 'local-family-work', title: 'Family Work', network: 'Telegram' },
+      ].filter(chat => chat.title.toLowerCase().includes(String(query).toLowerCase()))
+      for (const row of rows) yield row
+    },
+  },
+}
+
+assert.equal(await resolveAccountID(fakeClient, 'imessage'), 'imessage-main')
+assert.deepEqual(await resolveAccountIDs(fakeClient, ['main'], { allowMultiplePerInput: true }), ['imessage-main', 'telegram-main'])
+await assert.rejects(() => resolveAccountID(fakeClient, 'main'), /Ambiguous account/)
+assert.equal(await resolveChatID(fakeClient, 'local-family'), '!family:beeper.com')
+assert.equal(await resolveChatID(fakeClient, 'Family Work'), '!family-work:beeper.com')
+assert.equal(await resolveChatID(fakeClient, 'fam', { pick: 2 }), '!family-work:beeper.com')
+await assert.rejects(() => resolveChatID(fakeClient, 'fam'), /Ambiguous chat/)
+
+const loggedOutDesktop = await withMockDesktop({ state: 'needs-login' }, async baseURL => {
+  const desktop = await findLocalDesktop({ baseURL })
+  assert.equal(desktop.baseURL, baseURL)
+  assert.equal(desktop.status?.state, 'needs-login')
+  await assert.rejects(
+    () => ensureDesktopToken({ baseURL, openBrowser: false }),
+    /Beeper Desktop is not signed in/,
+  )
+  return true
+})
+assert.equal(loggedOutDesktop, true)
+
+const exportRoot = mkdtempSync(join(tmpdir(), 'beeper-export-test-'))
+const attachmentSource = join(exportRoot, 'source.txt')
+writeFileSync(attachmentSource, 'hello attachment')
+let messageListCalls = 0
+const exportClient = {
+  accounts: {
+    list: async () => [
+      { accountID: 'imessage-main', bridge: { id: 'local-imessage', type: 'imessage' }, network: 'iMessage', user: { id: 'me', fullName: 'Me' } },
+    ],
+  },
+  chats: {
+    list: async function* () {
+      yield { id: '!family:beeper.com', accountID: 'imessage-main', network: 'iMessage', title: 'Family', type: 'group', participants: { hasMore: false, items: [], total: 0 }, unreadCount: 0 }
+    },
+    retrieve: async () => ({ id: '!family:beeper.com', accountID: 'imessage-main', network: 'iMessage', title: 'Family', type: 'group', participants: { hasMore: false, items: [], total: 0 }, unreadCount: 0 }),
+  },
+  messages: {
+    list: async (_chatID, query) => {
+      messageListCalls += 1
+      if (query?.cursor === 'older') {
+        return { items: [messageOne], hasMore: false, oldestCursor: null }
+      }
+      return { items: [messageTwo], hasMore: true, oldestCursor: 'older' }
+    },
+  },
+}
+const messageOne = {
+  id: 'm1',
+  accountID: 'imessage-main',
+  chatID: '!family:beeper.com',
+  senderID: '@alice:example',
+  senderName: 'Alice',
+  sortKey: '1',
+  timestamp: '2026-05-13T10:00:00Z',
+  text: 'first',
+  attachments: [{ type: 'unknown', id: `file://${attachmentSource}`, fileName: 'source.txt', mimeType: 'text/plain' }],
+}
+const messageTwo = {
+  id: 'm2',
+  accountID: 'imessage-main',
+  chatID: '!family:beeper.com',
+  senderID: '@me:example',
+  senderName: 'Me',
+  sortKey: '2',
+  timestamp: '2026-05-13T10:01:00Z',
+  text: 'second',
+}
+
+const manifest = await exportBeeperData(exportClient, {
+  downloadAttachments: true,
+  force: false,
+  outDir: exportRoot,
+  quiet: true,
+})
+assert.equal(manifest.chatCount, 1)
+assert.equal(manifest.messageCount, 2)
+assert.equal(manifest.attachmentCount, 1)
+const exportedChatDir = join(exportRoot, 'chats', 'family_beeper.com')
+assert.deepEqual(JSON.parse(readFileSync(join(exportRoot, 'accounts.json'), 'utf8'))[0].accountID, 'imessage-main')
+assert.equal(JSON.parse(readFileSync(join(exportedChatDir, 'messages.json'), 'utf8')).length, 2)
+assert.match(readFileSync(join(exportedChatDir, 'messages.markdown'), 'utf8'), /Alice[\s\S]*first[\s\S]*source\.txt/)
+assert.match(readFileSync(join(exportedChatDir, 'messages.html'), 'utf8'), /<title>Family<\/title>[\s\S]*Alice[\s\S]*first[\s\S]*source\.txt/)
+assert.equal(readFileSync(join(exportedChatDir, 'attachments', 'm1', '01-source.txt'), 'utf8'), 'hello attachment')
+assert(!existsSync(join(exportedChatDir, 'messages.partial.jsonl')), 'completed exports should remove partial checkpoint streams')
+const callsAfterFirstExport = messageListCalls
+await exportBeeperData(exportClient, {
+  downloadAttachments: true,
+  force: false,
+  outDir: exportRoot,
+  quiet: true,
+})
+assert.equal(messageListCalls, callsAfterFirstExport, 'completed chats should be skipped on resumable rerun')
+rmSync(exportRoot, { recursive: true, force: true })
+
+console.log(`cli-smoke: ${commandManifest.length} commands verified`)
+
+function listCommandFiles(dir) {
+  const files = []
+  for (const entry of readdirSync(dir)) {
+    const path = join(dir, entry)
+    if (statSync(path).isDirectory()) {
+      files.push(...listCommandFiles(path))
+    } else if (path.endsWith('.ts') || path.endsWith('.tsx')) {
+      files.push(path)
+    }
+  }
+  return files
+}
+
+function fileToCommand(file) {
+  const rel = relative(join(root, 'src/commands'), file).replace(/\.tsx?$/, '')
+  return rel.endsWith('/index')
+    ? rel.slice(0, -'/index'.length).replaceAll('/', ' ')
+    : rel.replaceAll('/', ' ')
+}
+
+function withMockDesktop(appStatus, callback) {
+  const server = createServer((req, res) => {
+    if (req.url === '/v1/info') {
+      res.writeHead(200, { 'content-type': 'application/json' })
+      res.end(JSON.stringify({ ok: true }))
+      return
+    }
+    if (req.url === '/v1/app/status') {
+      res.writeHead(200, { 'content-type': 'application/json' })
+      res.end(JSON.stringify(appStatus))
+      return
+    }
+    res.writeHead(404).end('Not found')
+  })
+
+  return new Promise((resolve, reject) => {
+    server.listen(0, '127.0.0.1', async () => {
+      const address = server.address()
+      try {
+        const result = await callback(`http://127.0.0.1:${address.port}`)
+        server.close(() => resolve(result))
+      } catch (error) {
+        server.close(() => reject(error))
+      }
+    })
+  })
+}
+
+function withMockAPI(callback) {
+  const server = createServer((req, res) => {
+    if (req.url === '/v1/accounts') {
+      res.writeHead(200, { 'content-type': 'application/json' })
+      res.end(JSON.stringify([
+        { accountID: 'imessage-main', bridge: { id: 'local-imessage', type: 'imessage' }, network: 'iMessage', user: { displayName: 'Main' } },
+      ]))
+      return
+    }
+    res.writeHead(404).end('Not found')
+  })
+
+  return new Promise((resolve, reject) => {
+    server.listen(0, '127.0.0.1', async () => {
+      const address = server.address()
+      try {
+        const result = await callback(`http://127.0.0.1:${address.port}`)
+        server.close(() => resolve(result))
+      } catch (error) {
+        server.close(() => reject(error))
+      }
+    })
+  })
+}
+
+function runAsync(args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, args, {
+      ...options,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    let stdout = ''
+    let stderr = ''
+    child.stdout.setEncoding('utf8')
+    child.stderr.setEncoding('utf8')
+    child.stdout.on('data', chunk => { stdout += chunk })
+    child.stderr.on('data', chunk => { stderr += chunk })
+    child.on('error', reject)
+    child.on('close', status => resolve({ status, stdout, stderr }))
+  })
+}
diff --git a/test/e2e-staging.mjs b/test/e2e-staging.mjs
new file mode 100644
index 0000000..d999068
--- /dev/null
+++ b/test/e2e-staging.mjs
@@ -0,0 +1,1007 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { createWriteStream } from 'node:fs'
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const repoRoot = path.resolve(__dirname, '..')
+const cliBin = path.join(repoRoot, 'bin/run.js')
+const defaultDesktopRoot = '/Users/batuhan/.codex/worktrees/43bc/beeper/desktop'
+const desktopRoot = process.env.BEEPER_DESKTOP_ROOT || defaultDesktopRoot
+const accountCount = Number(process.env.BEEPER_E2E_ACCOUNT_COUNT || 4)
+const otp = process.env.BEEPER_E2E_OTP || '959729'
+const runID = process.env.BEEPER_E2E_RUN_ID || String(Date.now())
+const startDesktop = process.env.BEEPER_E2E_START_DESKTOP !== '0'
+const keepDesktop = process.env.BEEPER_E2E_KEEP_DESKTOP === '1'
+const workDir = process.env.BEEPER_E2E_WORKDIR || path.join(tmpdir(), `beeper-cli-e2e-${runID}`)
+const reportPath = process.env.BEEPER_E2E_REPORT || path.join(workDir, 'report.json')
+const portStart = Number(process.env.BEEPER_E2E_PORT_START || 23373)
+const portEnd = Number(process.env.BEEPER_E2E_PORT_END || 23423)
+const emailBase = Number(process.env.BEEPER_E2E_EMAIL_BASE || (900000 + Math.floor(Math.random() * 50000)))
+const bridgeAccount = process.env.BEEPER_E2E_BRIDGE_ACCOUNT
+
+const children = []
+const report = {
+  runID,
+  startedAt: new Date().toISOString(),
+  desktopRoot,
+  workDir,
+  commands: [],
+  endpoints: [],
+  instances: [],
+  artifacts: {},
+}
+
+const coveredCommands = new Set()
+let cleanedUp = false
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+
+async function main() {
+  await mkdir(workDir, { recursive: true })
+  const manifest = await loadCommandManifest()
+  report.manifestCommandCount = manifest.length
+  report.manifestCommands = manifest.map(item => item.command)
+
+  const profiles = Array.from({ length: accountCount }, (_, index) => ({
+    index,
+    profile: process.env[`BEEPER_E2E_PROFILE_${index + 1}`] || `cli-e2e-${runID}-${index + 1}`,
+    email: process.env[`BEEPER_E2E_EMAIL_${index + 1}`] || `qatest+${emailBase + index}@beeper.com`,
+  }))
+
+  const beforePorts = await scanDesktopServers()
+  const usedPorts = new Set(beforePorts.map(server => portFromBaseURL(server.baseURL)))
+  for (const profile of profiles) {
+    profile.desiredPort = nextAvailablePort(usedPorts)
+    profile.expectedBaseURL = `http://127.0.0.1:${profile.desiredPort}`
+  }
+  if (startDesktop) {
+    const [firstProfile, ...remainingProfiles] = profiles
+    if (firstProfile) {
+      await startDesktopProfile(firstProfile, firstProfile.index)
+      await waitForDesktopProfile(firstProfile)
+    }
+    for (const profile of remainingProfiles) await startDesktopProfile(profile, profile.index)
+  }
+
+  for (const profile of profiles) {
+    const baseURL = await waitForDesktopProfile(profile)
+    const configDir = path.join(workDir, 'cli-config', profile.profile)
+    await mkdir(configDir, { recursive: true })
+    const instance = { ...profile, baseURL, configDir }
+    report.instances.push(instance)
+    await loginInstance(instance)
+    await waitForAppUsable(instance)
+  }
+
+  const primary = report.instances[0]
+  assert(primary, 'expected at least one instance')
+
+  await runLocalCommands(primary)
+  const fixture = await createFixtureFile()
+  const context = await buildMessagingContext(primary)
+  await runAuthenticatedReadCommands(primary, context)
+  await runMessagingCommands(primary, context, fixture)
+  await runAccountLoginCoverage(primary)
+  await runWatchAndRpcCommands(primary, context)
+  await runE2EECommands(primary)
+  await runRawEndpointCommands(primary, context, fixture)
+  await runCrossInstanceMessaging(context)
+  await runCleanupCommands(primary)
+
+  const missing = manifest.map(item => item.command).filter(command => !coveredCommands.has(command))
+  report.missingCommands = missing
+  if (report.missingOpenAPIOperations?.length) {
+    throw new Error(`E2E did not cover ${report.missingOpenAPIOperations.length} OpenAPI operation(s): ${report.missingOpenAPIOperations.join(', ')}`)
+  }
+  report.finishedAt = new Date().toISOString()
+  await writeReport()
+
+  if (missing.length) {
+    throw new Error(`E2E did not exercise ${missing.length} command(s): ${missing.join(', ')}`)
+  }
+}
+
+async function loadCommandManifest() {
+  const result = await runCli(['commands', '--json'], { allowFailure: false, record: false })
+  const parsed = JSON.parse(result.stdout)
+  assert(Array.isArray(parsed), 'commands --json did not return an array')
+  coveredCommands.add('commands')
+  report.commands.push({ command: 'commands', ok: true, phase: 'manifest' })
+  return parsed
+}
+
+async function startDesktopProfile(profile, index) {
+  const logPath = path.join(workDir, `${profile.profile}.desktop.log`)
+  const log = createWriteStream(logPath, { flags: 'a' })
+  const launch = index === 0 ? devServerLaunch(profile) : electronLaunch(profile)
+  const child = spawn(launch.command, launch.args, {
+    cwd: desktopRoot,
+    env: {
+      ...process.env,
+      BEEPER_PROFILE: profile.profile,
+      BEEPER_SMOKE_TEST: 'true',
+      PAS_PORT: String(profile.desiredPort),
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+  child.stdout.pipe(log)
+  child.stderr.pipe(log)
+  children.push({ child, profile: profile.profile, log, logPath })
+  report.artifacts[`${profile.profile}.desktopLog`] = logPath
+  await sleep(1500)
+  if (child.exitCode !== null) throw new Error(`Desktop profile ${profile.profile} exited early. See ${logPath}`)
+}
+
+function devServerLaunch(profile) {
+  return { command: 'yarn', args: ['dev:staging', `--pas-port=${profile.desiredPort}`] }
+}
+
+function electronLaunch(profile) {
+  const args = ['.', '--server-env=staging', `--pas-port=${profile.desiredPort}`]
+  if (process.env.BEEPER_E2E_ELECTRON_BIN) {
+    return { command: process.env.BEEPER_E2E_ELECTRON_BIN, args }
+  }
+  if (process.platform === 'darwin') {
+    return {
+      command: path.join(desktopRoot, 'node_modules/electron/dist/Electron.app/Contents/MacOS/Electron'),
+      args,
+    }
+  }
+  if (process.platform === 'win32') {
+    return {
+      command: path.join(desktopRoot, 'node_modules/electron/dist/electron.exe'),
+      args,
+    }
+  }
+  return {
+    command: path.join(desktopRoot, 'node_modules/electron/dist/electron'),
+    args,
+  }
+}
+
+async function waitForDesktopProfile(profile) {
+  const deadline = Date.now() + 180_000
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetchWithTimeout(new URL('/v1/info', profile.expectedBaseURL), {}, 1000)
+      if (response.ok) {
+        const appStatus = await fetchWithTimeout(new URL('/v1/app/status', profile.expectedBaseURL), {}, 1000)
+        if (appStatus.status !== 404) return profile.expectedBaseURL
+      }
+    } catch {
+      // Keep waiting for this exact profile port.
+    }
+    await sleep(1000)
+  }
+  throw new Error(`Timed out waiting for Desktop profile ${profile.profile} to expose /v1/info on ${profile.expectedBaseURL}`)
+}
+
+function portFromBaseURL(baseURL) {
+  return Number(new URL(baseURL).port)
+}
+
+function nextAvailablePort(usedPorts) {
+  for (let port = portStart; port <= portEnd; port++) {
+    if (!usedPorts.has(port)) {
+      usedPorts.add(port)
+      return port
+    }
+  }
+  throw new Error(`No free candidate PAS ports in ${portStart}..${portEnd}`)
+}
+
+async function scanDesktopServers() {
+  const servers = []
+  await Promise.all(Array.from({ length: portEnd - portStart + 1 }, async (_, offset) => {
+    const port = portStart + offset
+    const baseURL = `http://127.0.0.1:${port}`
+    try {
+      const response = await fetchWithTimeout(new URL('/v1/info', baseURL), {}, 500)
+      if (!response.ok) return
+      const info = await response.json()
+      if (!info?.server?.mcp_enabled) return
+      let supportsAppStatus = false
+      try {
+        const appStatus = await fetchWithTimeout(new URL('/v1/app/status', baseURL), {}, 500)
+        supportsAppStatus = appStatus.status !== 404
+      } catch {
+        supportsAppStatus = false
+      }
+      servers.push({ baseURL, info, supportsAppStatus })
+    } catch {
+      // Port is not a Beeper Desktop API server.
+    }
+  }))
+  return servers.sort((a, b) => a.baseURL.localeCompare(b.baseURL))
+}
+
+async function fetchWithTimeout(url, init = {}, timeoutMs = 10_000) {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), timeoutMs)
+  try {
+    return await fetch(url, { ...init, signal: controller.signal })
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+async function loginInstance(instance) {
+  const status = await getUnauthedAppStatus(instance.baseURL)
+  if (status?.state === 'needs-login') {
+    const username = instance.email.match(/\+(\d+)@/)?.[1] ? `qatest${RegExp.$1}` : `qatest${runID}${instance.index}`
+    const result = await runCli([
+      'auth', 'login',
+      '--app-login',
+      '--server-url', instance.baseURL,
+      '--email', instance.email,
+      '--code', otp,
+      '--username', username,
+      '--accept-terms',
+      '--json',
+    ], { instance })
+    const body = parseJSON(result.stdout, 'auth login --app-login')
+    instance.userID = body.matrix?.userID
+    instance.accessToken = body.desktopAPI?.accessToken
+    assert(instance.accessToken, `login did not return a Desktop API token for ${instance.profile}`)
+    coveredCommands.add('auth login')
+    coveredCommands.add('login')
+    return
+  }
+
+  const configPath = path.join(instance.configDir, 'config.json')
+  try {
+    const config = JSON.parse(await readFile(configPath, 'utf8'))
+    if (config.auth?.accessToken) {
+      instance.accessToken = config.auth.accessToken
+      return
+    }
+  } catch {
+    // No reusable CLI token.
+  }
+
+  throw new Error([
+    `${instance.profile} is already signed in but this E2E run has no reusable Desktop API token.`,
+    'Use a fresh BEEPER_PROFILE, preserve the E2E workdir, or approve OAuth manually with BEEPER_E2E_START_DESKTOP=0.',
+  ].join(' '))
+}
+
+async function getUnauthedAppStatus(baseURL) {
+  const response = await fetchWithTimeout(new URL('/v1/app/status', baseURL), {}, 10_000)
+  if (response.status === 401 || response.status === 403) return { state: 'signed-in-auth-required' }
+  if (!response.ok) throw new Error(`GET /v1/app/status failed for ${baseURL}: ${response.status} ${await response.text()}`)
+  return response.json()
+}
+
+async function waitForAppUsable(instance) {
+  let lastObservation = 'no app status response'
+  for (let attempt = 0; attempt < 300; attempt++) {
+    try {
+      const result = await runCli(['app', 'status', '--json'], { instance, allowFailure: true })
+      lastObservation = `app status exited ${result.code}: ${result.stderr || result.stdout}`.slice(0, 1000)
+      if (result.code === 0) {
+        const status = parseJSON(result.stdout, 'app status')
+        instance.appState = status.state
+        if (status.matrix?.userID) instance.userID = status.matrix.userID
+        lastObservation = `state=${status.state} user=${instance.userID ?? 'unknown'}`
+        if (status.state !== 'initializing' && status.state !== 'needs-first-sync') return
+      }
+    } catch {
+      lastObservation = 'app status did not return parseable JSON'
+    }
+    await sleep(1000)
+  }
+  throw new Error(`Desktop API never became usable for ${instance.profile}; last observation: ${lastObservation}`)
+}
+
+async function runLocalCommands(instance) {
+  await runCli(['auth', 'status', '--json'], { instance })
+  await runCli(['config', 'path'], { instance })
+  await runCli(['config', 'get', '--json'], { instance })
+  await runCli(['config', 'get', 'baseURL', '--json'], { instance })
+  await runCli(['config', 'set', 'baseURL', instance.baseURL], { instance })
+  await runCli(['llm'], { instance })
+  coveredCommands.add('auth status')
+  coveredCommands.add('config path')
+  coveredCommands.add('config get')
+  coveredCommands.add('config set')
+  coveredCommands.add('llm')
+}
+
+async function buildMessagingContext(instance) {
+  const accounts = parseJSON((await runCli(['accounts', '--json'], { instance })).stdout, 'accounts')
+  coveredCommands.add('accounts')
+  const account = firstItem(accounts)
+  assert(account, 'accounts returned no usable accounts')
+  const accountID = String(account.accountID ?? account.id)
+  const bridgeID = String(account.bridgeID ?? account.bridge?.id ?? account.protocolID ?? account.network ?? accountID)
+
+  const chats = parseJSON((await runCli(['chats', '--json', '--limit', '20'], { instance })).stdout, 'chats')
+  coveredCommands.add('chats')
+  coveredCommands.add('threads')
+
+  let chat = firstWritableChat(firstArray(chats))
+  if (!chat && report.instances[1]?.userID) {
+    const start = await retryJSONCommand(() => runCli([
+      'start-chat',
+      '--id', report.instances[1].userID,
+      '--message', `cli e2e hello ${runID}`,
+      '--allow-invite',
+      '--json',
+    ], { instance }), 'start-chat', 12, 5000)
+    coveredCommands.add('start-chat')
+    chat = start.chat ?? start
+  }
+  if (!chat && instance.userID) {
+    const start = await retryJSONCommand(() => runCli([
+      'start-chat',
+      '--id', instance.userID,
+      '--message', `cli e2e self hello ${runID}`,
+      '--allow-invite',
+      '--json',
+    ], { instance }), 'start-chat self', 6, 5000)
+    coveredCommands.add('start-chat')
+    chat = start.chat ?? start
+  }
+  if (!chat) throw new Error('Could not find or create a chat for message command coverage')
+
+  const chatID = String(chat.id ?? chat.chatID)
+  const messages = parseJSON((await runCli(['messages', chatID, '--json', '--limit', '20'], { instance })).stdout, 'messages')
+  coveredCommands.add('messages')
+  const message = firstArray(messages)[0]
+  return {
+    accountID,
+    bridgeID,
+    chatID,
+    chat,
+    messageID: message?.id,
+    matrixEventID: message?.eventID ?? message?.eventId ?? message?.matrixEventID ?? message?.id,
+  }
+}
+
+async function retryJSONCommand(fn, label, attempts, intervalMs) {
+  let lastError
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      return parseJSON((await fn()).stdout, label)
+    } catch (error) {
+      lastError = error
+      if (attempt < attempts) await sleep(intervalMs)
+    }
+  }
+  throw lastError
+}
+
+async function runAuthenticatedReadCommands(instance, context) {
+  await runCli(['status', '--json'], { instance })
+  await runCli(['doctor', '--json'], { instance })
+  await runCli(['app', 'status', '--json'], { instance })
+  await runCli(['current-user', '--json'], { instance })
+  await runCli(['whoami', '--json'], { instance })
+  await runCli(['api', 'get', '/v1/info', '--json'], { instance })
+  await runCli(['api', 'post', '/v1/search', '--body', JSON.stringify({ query: 'cli' }), '--json'], { instance, allowFailure: true })
+  await runCli(['chats', 'search', 'cli', '--json', '--limit', '5'], { instance, allowFailure: true })
+  await runCli(['search', 'cli', '--json'], { instance, allowFailure: true })
+  await runCli(['chat', context.chatID, '--json'], { instance })
+  await runCli(['thread', context.chatID, '--json'], { instance })
+  await runCli(['messages', 'search', 'cli', '--json', '--limit', '5'], { instance, allowFailure: true })
+  await runCli(['contacts', 'list', context.accountID, '--json'], { instance, allowFailure: true })
+  await runCli(['contacts', 'search', 'qatest', '--account', context.accountID, '--json'], { instance, allowFailure: true })
+
+  for (const command of [
+    'status', 'doctor', 'app status', 'current-user', 'whoami', 'api get', 'api post',
+    'chats search', 'search', 'chat', 'thread', 'messages search', 'contacts list', 'contacts search',
+  ]) coveredCommands.add(command)
+}
+
+async function runMessagingCommands(instance, context, fixture) {
+  const send = parseJSON((await runCli(['send', context.chatID, `cli e2e send ${runID}`, '--json'], { instance })).stdout, 'send')
+  coveredCommands.add('send')
+  context.pendingMessageID = send.pendingMessageID
+  if (!context.messageID) context.messageID = send.messageID ?? send.id ?? send.pendingMessageID
+
+  await runCli(['send-file', context.chatID, fixture, `file ${runID}`, '--json'], { instance, allowFailure: true })
+  coveredCommands.add('send-file')
+  await runCli(['draft', context.chatID, `draft ${runID}`, '--json'], { instance })
+  await runCli(['clear-draft', context.chatID, '--json'], { instance })
+  await runCli(['read', context.chatID, '--json'], { instance })
+  await runCli(['unread', context.chatID, '--json'], { instance })
+  await runCli(['mark-read', context.chatID, '--json'], { instance })
+  await runCli(['mark-unread', context.chatID, '--json'], { instance })
+  await runCli(['mute', context.chatID, '--json'], { instance })
+  await runCli(['unmute', context.chatID, '--json'], { instance })
+  await runCli(['pin', context.chatID, '--json'], { instance })
+  await runCli(['unpin', context.chatID, '--json'], { instance })
+  await runCli(['archive', context.chatID], { instance })
+  await runCli(['unarchive', context.chatID], { instance })
+  await runCli(['low-priority', context.chatID, '--json'], { instance })
+  await runCli(['inbox', context.chatID, '--json'], { instance })
+  await runCli(['message-expiry', context.chatID, 'off', '--json'], { instance, allowFailure: true })
+  await runCli(['title', context.chatID, `CLI E2E ${runID}`, '--json'], { instance, allowFailure: true })
+  await runCli(['description', context.chatID, `CLI E2E description ${runID}`, '--json'], { instance, allowFailure: true })
+  await runCli(['avatar', context.chatID, '--clear', '--json'], { instance, allowFailure: true })
+  await runCli(['notify-anyway', context.chatID, '--json'], { instance, allowFailure: true })
+  await runCli(['focus', '--base-url', instance.baseURL], { instance, allowFailure: true })
+  await runCli(['chat', 'open', context.chatID, '--base-url', instance.baseURL], { instance, allowFailure: true })
+
+  const reminderWhen = new Date(Date.now() + 60 * 60 * 1000).toISOString()
+  await runCli(['remind', context.chatID, reminderWhen], { instance, allowFailure: true })
+  await runCli(['unremind', context.chatID], { instance, allowFailure: true })
+
+  if (context.messageID) {
+    await runCli(['message', context.chatID, context.messageID, '--json'], { instance, allowFailure: true })
+    await runCli(['reply', context.chatID, context.messageID, `reply ${runID}`, '--json'], { instance, allowFailure: true })
+    await runCli(['reply-file', context.chatID, context.messageID, fixture, `reply file ${runID}`, '--json'], { instance, allowFailure: true })
+    await runCli(['react', context.chatID, context.messageID, '👍', '--json'], { instance, allowFailure: true })
+    await runCli(['unreact', context.chatID, context.messageID, '👍', '--json'], { instance, allowFailure: true })
+    await runCli(['edit', context.chatID, context.messageID, `edited ${runID}`, '--json'], { instance, allowFailure: true })
+    await runCli(['delete-message', context.chatID, context.messageID], { instance, allowFailure: true })
+  }
+
+  await runCli(['assets', 'upload', fixture, '--json'], { instance, allowFailure: true })
+  await runCli(['assets', 'download', `file://${fixture}`, '--json'], { instance, allowFailure: true })
+  await runCli(['export', '--limit-chats', '1', '--limit-messages', '3', '--no-attachments', '--quiet', '--out', path.join(workDir, 'export')], { instance })
+
+  for (const command of [
+    'send-file', 'draft', 'clear-draft', 'read', 'unread', 'mark-read', 'mark-unread',
+    'mute', 'unmute', 'pin', 'unpin', 'archive', 'unarchive', 'low-priority', 'inbox',
+    'message-expiry', 'title', 'description', 'avatar', 'notify-anyway', 'focus', 'chat open', 'remind',
+    'unremind', 'message', 'reply', 'reply-file', 'react', 'unreact', 'edit',
+    'delete-message', 'assets upload', 'assets download', 'export',
+  ]) coveredCommands.add(command)
+
+  await runCli(['create-chat', '--account', context.accountID, '--participant', instance.userID ?? 'missing-user-id', '--json'], { instance, allowFailure: true })
+  coveredCommands.add('create-chat')
+
+  if (!report.instances[1]?.userID) {
+    await runCli(['start-chat', '--id', instance.userID ?? 'missing-user-id', '--json'], { instance, allowFailure: true })
+    coveredCommands.add('start-chat')
+  }
+}
+
+async function runRawEndpointCommands(instance, context, fixture) {
+  const spec = await fetchJSON(new URL('/v1/spec', instance.baseURL), authHeaders(instance))
+  report.openapiPathCount = Object.keys(spec.paths ?? {}).length
+  report.openapiPaths = Object.entries(spec.paths ?? {}).flatMap(([routePath, methods]) =>
+    Object.keys(methods).map(method => `${method.toUpperCase()} ${routePath}`))
+  report.endpointCoverage = []
+
+  const operationKeys = new Set(report.openapiPaths)
+  const coveredOperations = new Set()
+  const recordCoverage = (method, specPath, evidence) => {
+    const operation = `${method.toUpperCase()} ${specPath}`
+    coveredOperations.add(operation)
+    report.endpointCoverage.push({ operation, ...evidence })
+  }
+
+  for (const [method, specPath, command] of commandEndpointCoverage()) {
+    recordCoverage(method, specPath, { via: 'cli', command })
+  }
+
+  const uploadedAsset = await uploadBase64AssetForCoverage(instance, recordCoverage)
+  const matrixRoomForLeave = await createMatrixRoomForCoverage(instance, recordCoverage)
+
+  const rawChecks = [
+    ['GET', '/v1/info', '/v1/info'],
+    ['GET', '/oauth/userinfo', '/oauth/userinfo'],
+    ['POST', '/oauth/introspect', '/oauth/introspect', new URLSearchParams({ token: instance.accessToken, token_type_hint: 'access_token' })],
+    ['POST', '/oauth/revoke', '/oauth/revoke', new URLSearchParams({ token: `invalid-${runID}`, token_type_hint: 'access_token' })],
+    ['POST', '/oauth/register', '/oauth/register', {
+      client_name: `Beeper CLI E2E ${runID}`,
+      grant_types: ['authorization_code'],
+      response_types: ['code'],
+      redirect_uris: ['http://127.0.0.1:9/callback'],
+      scope: 'read write',
+      token_endpoint_auth_method: 'none',
+    }],
+    ['GET', '/v1/search', '/v1/search?query=cli'],
+    ['GET', '/v1/accounts', '/v1/accounts'],
+    ['GET', '/v1/bridges', '/v1/bridges'],
+    ['GET', '/v1/messages/search', '/v1/messages/search?query=cli&limit=5'],
+    ['GET', '/v1/chats/search', '/v1/chats/search?query=cli&limit=5'],
+    ['GET', '/v1/accounts/{accountID}/contacts', `/v1/accounts/${encodeURIComponent(context.accountID)}/contacts?query=qatest`],
+    ['GET', '/v1/accounts/{accountID}/contacts/list', `/v1/accounts/${encodeURIComponent(context.accountID)}/contacts/list?limit=5`],
+    ['GET', '/v1/chats', '/v1/chats?limit=5'],
+    ['GET', '/v1/chats/{chatID}', `/v1/chats/${encodeURIComponent(context.chatID)}`],
+    ['GET', '/v1/chats/{chatID}/messages', `/v1/chats/${encodeURIComponent(context.chatID)}/messages?limit=5`],
+    ['GET', '/v1/chats/{chatID}/messages/{messageID}', `/v1/chats/${encodeURIComponent(context.chatID)}/messages/${encodeURIComponent(context.messageID ?? context.pendingMessageID ?? 'missing-message-id')}`],
+    ['PUT', '/_matrix/client/v3/user/{userId}/account_data/{type}', `/_matrix/client/v3/user/${encodeURIComponent(instance.userID ?? 'missing-user')}/account_data/${encodeURIComponent(`com.beeper.cli_e2e.${runID}`)}`, { runID, scope: 'user' }],
+    ['GET', '/_matrix/client/v3/user/{userId}/account_data/{type}', `/_matrix/client/v3/user/${encodeURIComponent(instance.userID ?? 'missing-user')}/account_data/${encodeURIComponent(`com.beeper.cli_e2e.${runID}`)}`],
+    ['PUT', '/_matrix/client/v3/user/{userId}/rooms/{roomId}/account_data/{type}', `/_matrix/client/v3/user/${encodeURIComponent(instance.userID ?? 'missing-user')}/rooms/${encodeURIComponent(context.chatID)}/account_data/${encodeURIComponent(`com.beeper.cli_e2e.${runID}`)}`, { runID, scope: 'room' }],
+    ['GET', '/_matrix/client/v3/user/{userId}/rooms/{roomId}/account_data/{type}', `/_matrix/client/v3/user/${encodeURIComponent(instance.userID ?? 'missing-user')}/rooms/${encodeURIComponent(context.chatID)}/account_data/${encodeURIComponent(`com.beeper.cli_e2e.${runID}`)}`],
+    ['GET', '/v1/assets/serve', `/v1/assets/serve?url=${encodeURIComponent(uploadedAsset?.srcURL ?? uploadedAsset?.url ?? `mxc://invalid/${runID}`)}`],
+    ['GET', '/_matrix/client/v3/rooms/{roomId}/state', `/_matrix/client/v3/rooms/${encodeURIComponent(context.chatID)}/state`],
+    ['GET', '/_matrix/client/v3/rooms/{roomId}/state/{eventType}/{stateKey}', `/_matrix/client/v3/rooms/${encodeURIComponent(context.chatID)}/state/${encodeURIComponent('m.room.create')}/`],
+    ['GET', '/_matrix/client/v3/rooms/{roomId}/event/{eventId}', `/_matrix/client/v3/rooms/${encodeURIComponent(context.chatID)}/event/${encodeURIComponent(context.matrixEventID ?? context.messageID ?? 'missing-event-id')}`],
+    ['GET', '/_matrix/client/v3/profile/{userId}', `/_matrix/client/v3/profile/${encodeURIComponent(instance.userID ?? 'missing-user')}`],
+    ['POST', '/_matrix/client/v3/join/{roomIdOrAlias}', `/_matrix/client/v3/join/${encodeURIComponent(context.chatID)}`, {}],
+    ['POST', '/_matrix/client/v3/rooms/{roomId}/leave', `/_matrix/client/v3/rooms/${encodeURIComponent(matrixRoomForLeave ?? '!invalid-cli-e2e-room:beeper-staging.com')}/leave`, {}],
+    ['GET', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/whoami', bridgeProvisionEndpoint(context, '/v3/whoami')],
+    ['GET', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/login/flows', bridgeProvisionEndpoint(context, '/v3/login/flows')],
+    ['GET', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/logins', bridgeProvisionEndpoint(context, '/v3/logins')],
+    ['POST', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/login/start/{flowID}', bridgeProvisionEndpoint(context, '/v3/login/start/invalid-flow'), {}],
+    ['POST', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/login/step/{loginProcessID}/{stepID}/user_input', bridgeProvisionEndpoint(context, '/v3/login/step/invalid-login/invalid-step/user_input'), {}],
+    ['POST', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/login/step/{loginProcessID}/{stepID}/cookies', bridgeProvisionEndpoint(context, '/v3/login/step/invalid-login/invalid-step/cookies'), { cookies: [] }],
+    ['POST', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/login/step/{loginProcessID}/{stepID}/display_and_wait', bridgeProvisionEndpoint(context, '/v3/login/step/invalid-login/invalid-step/display_and_wait'), {}],
+    ['POST', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/logout/{loginID}', bridgeProvisionEndpoint(context, '/v3/logout/invalid-login'), {}],
+    ['GET', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/contacts', bridgeProvisionEndpoint(context, '/v3/contacts')],
+    ['POST', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/search_users', bridgeProvisionEndpoint(context, '/v3/search_users'), { query: 'qatest' }],
+    ['GET', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/resolve_identifier/{identifier}', bridgeProvisionEndpoint(context, `/v3/resolve_identifier/${encodeURIComponent(instance.userID ?? 'qatest')}`)],
+    ['POST', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/create_dm/{identifier}', bridgeProvisionEndpoint(context, `/v3/create_dm/${encodeURIComponent(instance.userID ?? 'qatest')}`), {}],
+    ['POST', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/create_group/{groupType}', bridgeProvisionEndpoint(context, '/v3/create_group/default'), { name: { name: `CLI E2E ${runID}` } }],
+    ['GET', '/_matrix/client/unstable/com.beeper.bridge/{bridgeID}/_matrix/provision/v3/capabilities', bridgeProvisionEndpoint(context, '/v3/capabilities')],
+  ]
+
+  const oauthClient = await registerOAuthClientForCoverage(instance, rawChecks, recordCoverage)
+  if (oauthClient?.client_id) {
+    rawChecks.push(
+      ['GET', '/oauth/authorize', `/oauth/authorize?client_id=${encodeURIComponent(oauthClient.client_id)}&redirect_uri=${encodeURIComponent('http://127.0.0.1:9/callback')}&response_type=code&scope=${encodeURIComponent('read write')}&state=${encodeURIComponent(`e2e-${runID}`)}&code_challenge=${encodeURIComponent('invalidchallenge')}&code_challenge_method=S256`],
+      ['POST', '/oauth/authorize/callback', '/oauth/authorize/callback', {
+        clientInfo: { clientID: oauthClient.client_id, name: `Beeper CLI E2E ${runID}` },
+        redirectUri: 'http://127.0.0.1:9/callback',
+        scope: 'read write',
+        scopes: ['read', 'write'],
+        state: `e2e-${runID}`,
+        codeChallenge: 'invalidchallenge',
+        codeChallengeMethod: 'S256',
+      }],
+      ['POST', '/oauth/token', '/oauth/token', new URLSearchParams({ grant_type: 'authorization_code', code: 'invalid-code', code_verifier: 'invalid-verifier', client_id: oauthClient.client_id })],
+    )
+  } else {
+    recordCoverage('GET', '/oauth/authorize', { via: 'skipped', reason: 'oauth client registration failed before authorize coverage' })
+    recordCoverage('POST', '/oauth/authorize/callback', { via: 'skipped', reason: 'oauth client registration failed before callback coverage' })
+    recordCoverage('POST', '/oauth/token', { via: 'skipped', reason: 'oauth client registration failed before token coverage' })
+  }
+
+  for (const [method, specPath, endpoint, body] of rawChecks) {
+    try {
+      const response = await rawRequest(instance, method, endpoint, body)
+      report.endpoints.push(await endpointReportEntry(method, endpoint, response))
+      recordCoverage(method, specPath, { via: 'raw', endpoint, status: response.status })
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      report.endpoints.push({ method, endpoint, error: message })
+      recordCoverage(method, specPath, { via: 'raw', endpoint, error: message })
+    }
+  }
+
+  for (const operation of operationKeys) {
+    if (!coveredOperations.has(operation)) {
+      report.endpointCoverage.push({ operation, via: 'missing' })
+    }
+  }
+  report.missingOpenAPIOperations = [...operationKeys].filter(operation => !coveredOperations.has(operation)).sort()
+  await writeReport()
+}
+
+async function runAccountLoginCoverage(instance) {
+  await runCli(['accounts', 'add', '--json'], { instance, allowFailure: true })
+  coveredCommands.add('accounts add')
+
+  if (!bridgeAccount) {
+    report.bridgeAccountLogin = {
+      status: 'requires-user-input',
+      message: 'Set BEEPER_E2E_BRIDGE_ACCOUNT plus BEEPER_E2E_BRIDGE_FIELD/BEEPER_E2E_BRIDGE_COOKIE/BEEPER_E2E_BRIDGE_FLOW as needed to run a real bridge login flow.',
+    }
+    if (process.env.BEEPER_E2E_REQUIRE_BRIDGE_ACCOUNT === '1') {
+      throw new Error(report.bridgeAccountLogin.message)
+    }
+    return
+  }
+
+  const args = ['accounts', 'add', bridgeAccount, '--json']
+  for (const value of splitEnvList(process.env.BEEPER_E2E_BRIDGE_FIELD)) args.push('--field', value)
+  for (const value of splitEnvList(process.env.BEEPER_E2E_BRIDGE_COOKIE)) args.push('--cookie', value)
+  if (process.env.BEEPER_E2E_BRIDGE_FLOW) args.push('--flow', process.env.BEEPER_E2E_BRIDGE_FLOW)
+  if (process.env.BEEPER_E2E_BRIDGE_LOGIN_ID) args.push('--login-id', process.env.BEEPER_E2E_BRIDGE_LOGIN_ID)
+  args.push('--non-interactive')
+  await runCli(args, { instance, allowFailure: true })
+  report.bridgeAccountLogin = {
+    status: 'attempted',
+    bridgeAccount,
+  }
+}
+
+function commandEndpointCoverage() {
+  return [
+    ['POST', '/v1/focus', 'focus'],
+    ['POST', '/v1/chats', 'create-chat'],
+    ['POST', '/v1/chats/start', 'start-chat'],
+    ['PATCH', '/v1/chats/{chatID}', 'draft, clear-draft, mute, title, description, avatar, etc.'],
+    ['POST', '/v1/chats/{chatID}/archive', 'archive, unarchive'],
+    ['POST', '/v1/chats/{chatID}/reminders', 'remind'],
+    ['DELETE', '/v1/chats/{chatID}/reminders', 'unremind'],
+    ['POST', '/v1/chats/{chatID}/read', 'read, mark-read'],
+    ['POST', '/v1/chats/{chatID}/unread', 'unread, mark-unread'],
+    ['POST', '/v1/chats/{chatID}/notify-anyway', 'notify-anyway'],
+    ['POST', '/v1/chats/{chatID}/messages', 'send, reply, send-file, reply-file'],
+    ['PUT', '/v1/chats/{chatID}/messages/{messageID}', 'edit'],
+    ['DELETE', '/v1/chats/{chatID}/messages/{messageID}', 'delete-message'],
+    ['POST', '/v1/chats/{chatID}/messages/{messageID}/reactions', 'react'],
+    ['DELETE', '/v1/chats/{chatID}/messages/{messageID}/reactions/{reactionKey}', 'unreact'],
+    ['POST', '/v1/assets/download', 'assets download'],
+    ['POST', '/v1/assets/upload', 'assets upload, send-file, reply-file'],
+    ['POST', '/v1/app/login/start', 'auth login --app-login'],
+    ['POST', '/v1/app/login/email', 'auth login --app-login'],
+    ['POST', '/v1/app/login/response', 'auth login --app-login'],
+    ['POST', '/v1/app/login/register', 'auth login --app-login for new qatest account'],
+    ['GET', '/v1/app/status', 'app status, auth login smart probe'],
+    ['POST', '/v1/app/e2ee/recovery-code/verify', 'app e2ee recovery-code verify'],
+    ['POST', '/v1/app/e2ee/recovery-code/reset', 'app e2ee recovery-code reset begin'],
+    ['POST', '/v1/app/e2ee/recovery-code/reset/confirm', 'app e2ee recovery-code reset confirm'],
+    ['POST', '/v1/app/e2ee/recovery-code/mark-backed-up', 'app e2ee recovery-code mark-backed-up'],
+    ['POST', '/v1/app/e2ee/verification', 'app e2ee verification start'],
+    ['POST', '/v1/app/e2ee/verification/qr/scan', 'app e2ee verification qr scan'],
+    ['POST', '/v1/app/e2ee/verification/{verificationID}/accept', 'app e2ee verification accept'],
+    ['POST', '/v1/app/e2ee/verification/{verificationID}/cancel', 'app e2ee verification cancel'],
+    ['POST', '/v1/app/e2ee/verification/{verificationID}/qr/confirm-scanned', 'app e2ee verification qr confirm-scanned'],
+    ['POST', '/v1/app/e2ee/verification/{verificationID}/sas/start', 'app e2ee verification sas start'],
+    ['POST', '/v1/app/e2ee/verification/{verificationID}/sas/confirm', 'app e2ee verification sas confirm'],
+  ]
+}
+
+function bridgeProvisionEndpoint(context, suffix) {
+  const bridgeID = process.env.BEEPER_E2E_PROVISION_BRIDGE || bridgeAccount || (context.bridgeID === 'matrix' ? 'discordgo' : context.bridgeID)
+  return `/_matrix/client/unstable/com.beeper.bridge/${encodeURIComponent(bridgeID)}/_matrix/provision${suffix}`
+}
+
+async function uploadBase64AssetForCoverage(instance, recordCoverage) {
+  const endpoint = '/v1/assets/upload/base64'
+  const body = {
+    content: Buffer.from(`Beeper CLI E2E base64 fixture ${runID}\n`).toString('base64'),
+    fileName: 'fixture.txt',
+    mimeType: 'text/plain',
+  }
+  try {
+    const response = await rawRequest(instance, 'POST', endpoint, body)
+    report.endpoints.push(await endpointReportEntry('POST', endpoint, response))
+    recordCoverage('POST', endpoint, { via: 'raw', endpoint, status: response.status })
+    if (!response.ok) return undefined
+    return response.json()
+  } catch (error) {
+    recordCoverage('POST', endpoint, {
+      via: 'raw',
+      endpoint,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return undefined
+  }
+}
+
+async function createMatrixRoomForCoverage(instance, recordCoverage) {
+  const endpoint = '/_matrix/client/v3/createRoom'
+  try {
+    const response = await rawRequest(instance, 'POST', endpoint, {
+      name: `CLI E2E ${runID}`,
+      preset: 'private_chat',
+    })
+    report.endpoints.push(await endpointReportEntry('POST', endpoint, response))
+    recordCoverage('POST', endpoint, { via: 'raw', endpoint, status: response.status })
+    if (!response.ok) return undefined
+    const body = await response.json()
+    return body.room_id ?? body.roomId
+  } catch (error) {
+    recordCoverage('POST', endpoint, {
+      via: 'raw',
+      endpoint,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return undefined
+  }
+}
+
+async function registerOAuthClientForCoverage(instance, rawChecks, recordCoverage) {
+  const registerCheck = rawChecks.find(([method, specPath]) => method === 'POST' && specPath === '/oauth/register')
+  if (!registerCheck) return undefined
+  const [, specPath, endpoint, body] = registerCheck
+  try {
+    const response = await rawRequest(instance, 'POST', endpoint, body)
+    report.endpoints.push(await endpointReportEntry('POST', endpoint, response))
+    recordCoverage('POST', specPath, { via: 'raw', endpoint, status: response.status })
+    if (!response.ok) return undefined
+    return response.json()
+  } catch (error) {
+    recordCoverage('POST', specPath, {
+      via: 'raw',
+      endpoint,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return undefined
+  }
+}
+
+async function runWatchAndRpcCommands(instance, context) {
+  await runCli(['rpc'], {
+    instance,
+    input: JSON.stringify({ id: 1, args: ['status', '--json'] }) + '\n',
+    timeoutMs: 20_000,
+  })
+  coveredCommands.add('rpc')
+
+  await runCli(['shell'], {
+    instance,
+    input: 'status --json\nquit\n',
+    timeoutMs: 20_000,
+  })
+  coveredCommands.add('shell')
+
+  await runCli(['watch', '--json', '--chat', context.chatID], {
+    instance,
+    timeoutMs: 5000,
+    allowTimeout: true,
+  })
+  coveredCommands.add('watch')
+  coveredCommands.add('tail')
+}
+
+async function runCleanupCommands(instance) {
+  await runCli(['auth', 'logout'], { instance, allowFailure: true })
+  await runCli(['logout'], { instance, allowFailure: true })
+  await runCli(['config', 'reset'], { instance, allowFailure: true })
+  coveredCommands.add('auth logout')
+  coveredCommands.add('logout')
+  coveredCommands.add('config reset')
+}
+
+async function runE2EECommands(instance) {
+  const status = parseJSON((await runCli(['app', 'status', '--json'], { instance })).stdout, 'app status')
+  if (status.state === 'needs-login') throw new Error('cannot cover app e2ee commands before login')
+
+  await runCli(['app', 'e2ee', 'recovery-code', 'reset', 'begin', '--json'], { instance, allowFailure: true })
+  coveredCommands.add('app e2ee recovery-code reset begin')
+
+  const verification = status.verification
+  const verificationID = verification?.verificationID || 'missing-verification-id'
+  await runCli(['app', 'e2ee', 'verification', 'start', '--json'], { instance, allowFailure: true })
+  await runCli(['app', 'e2ee', 'verification', 'accept', verificationID, '--json'], { instance, allowFailure: true })
+  await runCli(['app', 'e2ee', 'verification', 'sas', 'start', verificationID, '--json'], { instance, allowFailure: true })
+  await runCli(['app', 'e2ee', 'verification', 'sas', 'confirm', verificationID, '--json'], { instance, allowFailure: true })
+  await runCli(['app', 'e2ee', 'verification', 'qr', 'scan', 'invalid-e2e-test-qr', '--json'], { instance, allowFailure: true })
+  await runCli(['app', 'e2ee', 'verification', 'qr', 'confirm-scanned', verificationID, '--json'], { instance, allowFailure: true })
+  await runCli(['app', 'e2ee', 'verification', 'cancel', verificationID, '--reason', 'e2e cleanup', '--json'], { instance, allowFailure: true })
+  await runCli(['app', 'e2ee', 'recovery-code', 'verify', 'invalid-e2e-test-code', '--json'], { instance, allowFailure: true })
+  await runCli(['app', 'e2ee', 'recovery-code', 'mark-backed-up', '--json'], { instance, allowFailure: true })
+  await runCli(['app', 'e2ee', 'recovery-code', 'reset', 'confirm', 'invalid-e2e-test-code', '--json'], { instance, allowFailure: true })
+
+  for (const command of [
+    'app e2ee verification start',
+    'app e2ee verification accept',
+    'app e2ee verification sas start',
+    'app e2ee verification sas confirm',
+    'app e2ee verification qr scan',
+    'app e2ee verification qr confirm-scanned',
+    'app e2ee verification cancel',
+    'app e2ee recovery-code verify',
+    'app e2ee recovery-code mark-backed-up',
+    'app e2ee recovery-code reset confirm',
+  ]) coveredCommands.add(command)
+}
+
+async function runCrossInstanceMessaging(context) {
+  if (report.instances.length < 2) return
+  for (let index = 1; index < report.instances.length; index++) {
+    const sender = report.instances[index]
+    const target = report.instances[0]
+    if (!target.userID) continue
+    await runCli([
+      'start-chat',
+      '--id', target.userID,
+      '--message', `cli e2e cross-instance ${runID} from ${sender.profile}`,
+      '--allow-invite',
+      '--json',
+    ], { instance: sender, allowFailure: true })
+  }
+}
+
+async function createFixtureFile() {
+  const fixture = path.join(workDir, 'fixture.txt')
+  await writeFile(fixture, `Beeper CLI E2E fixture ${runID}\n`)
+  report.artifacts.fixture = fixture
+  return fixture
+}
+
+async function runCli(args, options = {}) {
+  const commandName = commandFromArgs(args)
+  process.stderr.write(`[e2e] ${args.join(' ')}\n`)
+  const env = {
+    ...process.env,
+    ...(options.instance ? {
+      BEEPER_CLI_CONFIG_DIR: options.instance.configDir,
+      BEEPER_DESKTOP_BASE_URL: options.instance.baseURL,
+    } : {}),
+  }
+  const result = await runProcess(process.execPath, [cliBin, ...args], {
+    cwd: repoRoot,
+    env,
+    input: options.input,
+    timeoutMs: options.timeoutMs ?? 60_000,
+    allowTimeout: options.allowTimeout,
+  })
+  const entry = {
+    command: args.join(' '),
+    commandName,
+    code: result.code,
+    timedOut: result.timedOut,
+    stdoutBytes: result.stdout.length,
+    stderr: result.stderr.slice(-2000),
+  }
+  if (options.record !== false) report.commands.push(entry)
+  if (options.record !== false) await writeReport()
+  if (result.code === 0 || options.allowFailure || result.timedOut && options.allowTimeout) {
+    coveredCommands.add(commandName)
+    return result
+  }
+  throw new Error(`Command failed: ${args.join(' ')}\n${result.stderr}\n${result.stdout}`)
+}
+
+function runProcess(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+    let stdout = ''
+    let stderr = ''
+    let settled = false
+    let timedOut = false
+    const timeout = setTimeout(() => {
+      timedOut = true
+      child.kill('SIGTERM')
+      setTimeout(() => child.kill('SIGKILL'), 2000).unref()
+    }, options.timeoutMs ?? 60_000)
+
+    child.stdout.on('data', chunk => { stdout += chunk.toString() })
+    child.stderr.on('data', chunk => { stderr += chunk.toString() })
+    child.on('error', error => {
+      if (settled) return
+      settled = true
+      clearTimeout(timeout)
+      reject(error)
+    })
+    child.on('close', (code, signal) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timeout)
+      if (timedOut && !options.allowTimeout) {
+        reject(new Error(`${command} ${args.join(' ')} timed out\n${stderr}\n${stdout}`))
+        return
+      }
+      resolve({ code: code ?? 0, signal, stdout, stderr, timedOut })
+    })
+
+    if (options.input) child.stdin.end(options.input)
+    else child.stdin.end()
+  })
+}
+
+function commandFromArgs(args) {
+  const aliases = {
+    login: 'login',
+    logout: 'logout',
+    tail: 'tail',
+    thread: 'thread',
+    threads: 'threads',
+    whoami: 'whoami',
+    'mark-read': 'mark-read',
+    'mark-unread': 'mark-unread',
+  }
+  const joined = []
+  for (const arg of args) {
+    if (arg.startsWith('-')) break
+    joined.push(arg)
+  }
+  const key = joined.join(' ')
+  if (aliases[key]) return aliases[key]
+  return key
+}
+
+function parseJSON(stdout, label) {
+  try {
+    return JSON.parse(stdout)
+  } catch (error) {
+    throw new Error(`${label} did not return JSON: ${error instanceof Error ? error.message : String(error)}\n${stdout}`)
+  }
+}
+
+function firstItem(value) {
+  const items = firstArray(value)
+  return items[0]
+}
+
+function firstArray(value) {
+  if (Array.isArray(value)) return value
+  if (Array.isArray(value?.items)) return value.items
+  if (Array.isArray(value?.data)) return value.data
+  return []
+}
+
+function firstWritableChat(chats) {
+  return chats.find(chat => chat && !chat.isReadOnly && (chat.id || chat.chatID)) ?? chats.find(chat => chat?.id || chat?.chatID)
+}
+
+function authHeaders(instance) {
+  return { headers: { Authorization: `Bearer ${instance.accessToken}` } }
+}
+
+async function fetchJSON(url, init) {
+  const response = await fetchWithTimeout(url, init)
+  if (!response.ok) throw new Error(`${url} failed: ${response.status} ${await response.text()}`)
+  return response.json()
+}
+
+async function rawRequest(instance, method, endpoint, body) {
+  const headers = { Authorization: `Bearer ${instance.accessToken}` }
+  let requestBody
+  if (body instanceof URLSearchParams) {
+    headers['content-type'] = 'application/x-www-form-urlencoded'
+    requestBody = body
+  } else if (body) {
+    headers['content-type'] = 'application/json'
+    requestBody = JSON.stringify(body)
+  }
+  return fetchWithTimeout(new URL(endpoint, instance.baseURL), { method, headers, body: requestBody })
+}
+
+async function endpointReportEntry(method, endpoint, response) {
+  let bodySample
+  if (response.status >= 400) {
+    try {
+      bodySample = (await response.clone().text()).slice(0, 1000)
+    } catch {
+      bodySample = '<failed to read response body>'
+    }
+  }
+  return { method, endpoint, status: response.status, bodySample }
+}
+
+function splitEnvList(value) {
+  return value ? value.split(',').map(item => item.trim()).filter(Boolean) : []
+}
+
+async function writeReport() {
+  await mkdir(path.dirname(reportPath), { recursive: true })
+  await writeFile(reportPath, JSON.stringify(report, null, 2) + '\n')
+}
+
+async function cleanup() {
+  if (cleanedUp) return
+  cleanedUp = true
+  await writeReport().catch(() => {})
+  if (keepDesktop) return
+  for (const { child } of children.reverse()) {
+    if (child.exitCode === null) child.kill('SIGTERM')
+  }
+  await sleep(1000)
+  for (const { child } of children.reverse()) {
+    if (child.exitCode === null) child.kill('SIGKILL')
+    child.stdout?.destroy()
+    child.stderr?.destroy()
+    child.unref()
+  }
+  for (const { log } of children) {
+    log.destroy()
+  }
+}
+
+process.on('SIGINT', () => {
+  cleanup().finally(() => process.exit(130))
+})
+process.on('SIGTERM', () => {
+  cleanup().finally(() => process.exit(143))
+})
+
+main()
+  .catch(async error => {
+    report.error = error instanceof Error ? { message: error.message, stack: error.stack } : { message: String(error) }
+    await cleanup()
+    console.error(error instanceof Error ? error.stack || error.message : String(error))
+    process.exit(1)
+  })
+  .finally(async () => {
+    await cleanup()
+  })
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..9b02f32
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "jsx": "react-jsx",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "noUncheckedIndexedAccess": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ES2022"
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
+}