opencode-buddy 0.3.1 → 0.3.4

package/README.md

@@ -24,88 +24,169 @@ A virtual ASCII pet companion that lives in the opencode TUI sidebar. Hatches, f
 └──────────────────────────┘
 ```
 
-The buddy blinks every 600ms. Switch species, watch it cheer when opencode finishes a turn, and get scared when a session errors.
+The buddy blinks every 600ms, animates inside the TUI sidebar, and reacts to your coding sessions.
 
 ## Install
 
-Requires Node.js ≥ 18 and opencode ≥ 1.15.
+Requires opencode ≥ 1.15.
 
 ```bash
 npm install -g opencode-buddy
 ```
 
-Add to your `~/.config/opencode/opencode.json`:
+The `postinstall` script automatically registers the plugin in both config files using the same spec. opencode picks the right entrypoint from the package's `exports` field:
+
+- `opencode-buddy` (main) → `src/server-plugin.js` (server plugin, no-op since 0.3.x)
+- `opencode-buddy` with kind `tui` → `src/tui-plugin.jsx` (TUI plugin)
+
+Both `~/.config/opencode/opencode.json` and `~/.config/opencode/tui.json` get the same `plugin: ["opencode-buddy"]` entry.
+
+If you have those config files as JSONC (with comments), the script skips them — add the entries manually:
+
+```jsonc
+// ~/.config/opencode/opencode.json
+{
+  "plugin": ["opencode-buddy"]
+}
+```
 
 ```json
+// ~/.config/opencode/tui.json
 {
+  "$schema": "https://opencode.ai/tui.json",
   "plugin": ["opencode-buddy"]
 }
 ```
 
 Restart opencode. The buddy appears in the sidebar.
 
-## How to interact
+## Usage
 
-The buddy has a `buddy` tool the LLM can call. Just talk to it:
+Once installed, type `/` in the prompt to see the slash commands. The buddy ships with six:
 
-```
-/buddy
-/feed the buddy
-/switch to a dragon
-/rename it to Sparky
-/can you show me the buddy's ascii art
-```
+| Slash command | Effect |
+| --- | --- |
+| `/buddy` | Show the buddy's current stats as a toast |
+| `/buddy-feed` | Feed the buddy (+25 hunger, -5 energy) |
+| `/buddy-play` | Play with the buddy (+20 happiness, +5 xp, -5 hunger) |
+| `/buddy-rest` | Let the buddy rest (+30 energy) |
+| `/buddy-rename` | Open a prompt to rename the buddy (max 20 chars) |
+| `/buddy-switch` | Open a picker to switch to duck, cat, dragon, axolotl, robot, or ghost |
 
-The LLM will call the `buddy` tool with the right action. Available actions:
+The buddy also reacts passively to your sessions:
 
-| Action | Effect |
-| --- | --- |
-| `status` | Print current stats |
-| `feed` | +25 hunger, -5 energy |
-| `play` | +20 happiness, -5 hunger, +5 xp |
-| `rest` | +30 energy |
-| `switch <species>` | Change to duck, cat, dragon, axolotl, robot, or ghost |
-| `rename <name>` | Rename (max 20 chars) |
-| `hatch [species] [name]` | Start a brand new buddy |
-| `ascii [frame]` | Return rendered ASCII art |
-| `path` | Path to the state file |
-| `help` | List actions |
+- `session.idle` → 4 second **celebrating** animation
+- `session.error` → 5 second **scared** animation
+- Energy < 20 → automatically transitions to **sleeping**
+- Hunger < 25 → transitions to **scared** for 30 seconds
+
+State is shared across all opencode sessions via `~/.config/opencode-buddy/state.json`. Open a session in a different terminal and your buddy is still there.
 
 ## Six species
 
 ```
-       duck                    cat                  dragon
-         __                /\_/\                  /\_/\
-       <(o )___          ( o.o )                ( o o )  ~~
-        ( ._> /           > ^ <                  > ^ < /
-         `--'            /|   |\                /|   |\
-      ~ idle ~         (_|   |_)               (_|   |_)
-                          meow                   rawr
-
-     axolotl                robot                  ghost
-      ^___^              [ O . O ]              .-"\"-.
-     (o . o)             /|#####|\              ( o . o )
-    \|_|_|/             / |#####| \             | ~  ~ |
-     \| |/               |     |                |     |
-      ) (               /| | | |\               \uuuuu/
-    ~ ambien              beep                   boo
+        duck                    cat                  dragon
+          __                /\_/\                  /\_/\
+        <(o )___          ( o.o )                ( o o )  ~~
+         ( ._> /           > ^ <                  > ^ < /
+          `--'            /|   |\                /|   |\
+       ~ idle ~         (_|   |_)               (_|   |_)
+                           meow                   rawr
+
+      axolotl                robot                  ghost
+       ^___^              [ O . O ]              .-"-"-.
+      (o . o)             /|#####|\              ( o . o )
+     \|_|_|/             / |#####| \             | ~  ~ |
+      \| |/               |     |                |     |
+       ) (               /| | | |\               \uuuuu/
+     ~ ambien              beep                   boo
 ```
 
-Each species has a per-character color palette. Idle state has 3 frames (blink loop) at 600ms per frame.
+Each species has a per-character color palette. The idle state is a 3-frame blink loop that runs at ~1.6 fps.
+
+## Architecture
+
+```mermaid
+flowchart LR
+    subgraph User
+        U[Opencode TUI user]
+    end
+
+    subgraph OpencodeTUI["opencode TUI process (binary)"]
+        direction TB
+        Config[("tui.json<br/>plugin: [...]")]
+        Runtime[TuiPluginRuntime]
+        Sidebar[Sidebar component]
+        Prompt[Prompt component]
+        Slots{{"slot registry<br/>sidebar_content"}}
+        Keymap{{"keymap<br/>(slash commands)"}}
+
+        Config --> Runtime
+        Runtime --> Slots
+        Runtime --> Keymap
+        Slots --> Sidebar
+        Keymap --> Prompt
+    end
+
+    subgraph Buddy["opencode-buddy plugin (jsx)"]
+        direction TB
+        TUIEntry["tui entry<br/>(id: opencode-buddy)"]
+        View[View component<br/>SolidJS]
+        AnimTick[setInterval 600ms<br/>frame++]
+        RefreshTick[setInterval 1500ms<br/>mtime poll]
+        SlashCmds["slash commands<br/>feed / play / rest /<br/>status / rename / switch"]
+
+        TUIEntry --> View
+        TUIEntry --> SlashCmds
+        View --> AnimTick
+        View --> RefreshTick
+    end
+
+    subgraph State["Persistent state"]
+        StateFile[("~/.config/<br/>opencode-buddy/<br/>state.json")]
+    end
+
+    subgraph OpencodeServer["opencode server (same process)"]
+        Bus{{"event bus"}}
+        Sessions[Session events<br/>session.idle<br/>session.error]
+    end
+
+    U -->|types| Prompt
+    Prompt -->|/buddy-feed etc| Keymap
+    Keymap --> SlashCmds
+    SlashCmds -->|read+write| StateFile
+    SlashCmds -->|toast feedback| U
+
+    Slots -->|invokes renderer| View
+    View -->|render frame| Sidebar
+    View -->|reads mtime| StateFile
+    RefreshTick -->|state changed| View
+    Bus -->|session.idle| View
+    Bus -->|session.error| View
+    View -->|write derived state| StateFile
+
+    classDef store fill:#1e293b,stroke:#64748b,color:#f1f5f9
+    class StateFile store
+```
 
-## How it works
+### Boot flow
 
-- **TUI plugin** (`src/tui-plugin.jsx`): registers `sidebar_content` slot, renders a Solid component that polls `~/.config/opencode-buddy/state.json` every 1.5s and animates at 6fps. Pure opencode-native — no tmux, no separate process.
-- **Server plugin** (`src/server-plugin.js`): registers a `buddy` tool the LLM can call. The same package exports both entrypoints (`main` for server, `exports["./tui"]` for TUI).
-- **State** at `~/.config/opencode-buddy/state.json` (~/.config is cross-platform via os.homedir()). Attributes decay over time. Sessions auto-celebrate on `session.idle` and auto-scare on `session.error`.
+1. opencode reads `~/.config/opencode/tui.json` and discovers the buddy entry under `plugin`.
+2. The TUI runtime loads `tui-plugin.jsx` from `opencode-buddy/tui`, which exports a `{ id, tui }` module.
+3. The `tui(api)` function runs once: it registers the `sidebar_content` slot and registers 6 slash commands on the keymap.
+4. The TUI's `<Slot name="sidebar_content" />` (in the sidebar component) resolves to the buddy's `View` component. Each render of the sidebar instantiates one `<View>`.
+5. The view runs two timers: a 1500 ms state-poll timer that reads `state.json` mtime, and a 600 ms animation timer that increments the frame counter.
+6. Slash commands typed in the prompt hit the keymap → buddy's `run()` → reads/writes `state.json` directly → toast feedback to the user.
+7. The view's reactive signals propagate state changes back to the sidebar render. No re-render of the TUI shell is needed.
 
-## Uninstall
+### Why two config files with the same spec?
 
-```bash
-npm uninstall -g opencode-buddy
-```
+opencode has separate plugin registries for the **server** (LLM tools, file watching) and the **TUI** (sidebar slots, slash commands, keybindings). When the same package spec appears in both, opencode looks at the package's `exports` field to pick the right entrypoint:
 
-Then remove `"opencode-buddy"` from your `opencode.json` `plugin` array.
+- `opencode.json` → `kind: "server"` → loads `src/server-plugin.js` via `main` (currently a no-op — we no longer expose an LLM tool)
+- `tui.json` → `kind: "tui"` → loads `src/tui-plugin.jsx` via `exports["./tui"]` (the sidebar slot + slash commands)
+
+This split lets slash commands update state instantly without round-tripping through the LLM, which is the right UX for "I want to feed my pet right now" interactions.
 
 ## Project layout
 
@@ -115,13 +196,23 @@ opencode-buddy/
 ├── README.md
 ├── LICENSE
 └── src/
-    ├── tui-plugin.jsx     # v2 TUI plugin, mounts to sidebar_content
-    ├── server-plugin.js   # v1 server plugin, exposes `buddy` tool
-    ├── species.js         # ASCII art + per-species color palettes
-    ├── state.js           # state machine (hunger/happiness/energy decay)
-    └── persistence.js     # state file reader/writer
+    ├── tui-plugin.jsx     # TUI plugin: slot + slash commands + event listeners
+    ├── server-plugin.js   # Server plugin: no-op (LLM tool removed in 0.3.x)
+    ├── species.js         # ASCII art + per-species color palettes + 3-frame idle loop
+    ├── state.js           # state machine: tick, feed, play, rest, rename, switchSpecies, deriveState
+    └── persistence.js     # atomic read/write of state.json
 ```
 
+State is held at `~/.config/opencode-buddy/state.json`. `~/.config` resolves via `os.homedir()` so it works on Linux, macOS, and Windows.
+
+## Uninstall
+
+```bash
+npm uninstall -g opencode-buddy
+```
+
+Then remove `"opencode-buddy"` from `opencode.json` and `"opencode-buddy/tui"` from `tui.json` (the npm uninstall doesn't auto-edit user config).
+
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-buddy",
-  "version": "0.3.1",
+  "version": "0.3.4",
   "description": "A virtual ASCII pet companion that lives in the opencode TUI sidebar. Hatches, feeds, plays, and reacts to what you're coding.",
   "type": "module",
   "main": "src/server-plugin.js",
@@ -11,6 +11,7 @@
   },
   "files": [
     "src",
+    "scripts",
     "README.md",
     "LICENSE"
   ],
@@ -29,6 +30,9 @@
   "engines": {
     "node": ">=18"
   },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.mjs"
+  },
   "author": "AMark-CS",
   "license": "MIT",
   "repository": {

package/scripts/postinstall.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+// Postinstall: register the buddy plugin in opencode config files so the user
+// only needs to run `npm install -g opencode-buddy` and restart opencode.
+//
+// We touch two files:
+//   - ~/.config/opencode/opencode.json   (server plugin)
+//   - ~/.config/opencode/tui.json        (TUI plugin, created if missing)
+//
+// We are idempotent: if the entry is already present, we leave it alone.
+// We never overwrite a user's existing config — we only add the `plugin` key.
+
+import { promises as fs } from "node:fs"
+import path from "node:path"
+import os from "node:os"
+
+const PLUGIN_SPEC = "opencode-buddy"
+const CONFIG_DIR = path.join(os.homedir(), ".config", "opencode")
+const SERVER_CONFIG = path.join(CONFIG_DIR, "opencode.json")
+const TUI_CONFIG = path.join(CONFIG_DIR, "tui.json")
+
+async function readJSON(filepath) {
+  try {
+    const raw = await fs.readFile(filepath, "utf8")
+    return { raw, data: JSON.parse(raw) }
+  } catch (err) {
+    if (err.code === "ENOENT") return null
+    throw err
+  }
+}
+
+function hasComments(raw) {
+  // JSONC comments: // line comments and /* block */ comments.
+  return /\/\/[^\n]*|\/\*[\s\S]*?\*\//.test(raw)
+}
+
+function ensurePluginArray(data, spec) {
+  if (!data || typeof data !== "object") return false
+  const list = Array.isArray(data.plugin) ? data.plugin : []
+  if (list.some((entry) => typeof entry === "string" && entry === spec)) return false
+  list.push(spec)
+  data.plugin = list
+  return true
+}
+
+async function updateConfig({ filepath, spec, fallback, mergeTopLevel }) {
+  let existing = await readJSON(filepath)
+
+  if (existing && hasComments(existing.raw)) {
+    // Don't touch JSONC files with comments — we'd strip them.
+    return { changed: false, created: false, skipped: true }
+  }
+
+  let data
+  let isNew
+
+  if (!existing) {
+    data = { ...fallback }
+    isNew = true
+  } else {
+    data = existing.data
+    isNew = false
+  }
+
+  if (mergeTopLevel) {
+    Object.assign(data, mergeTopLevel)
+  }
+
+  const changed = ensurePluginArray(data, spec)
+  if (!changed && !isNew) {
+    return { changed: false, created: false }
+  }
+
+  await fs.mkdir(path.dirname(filepath), { recursive: true })
+  const json = JSON.stringify(data, null, 2) + "\n"
+  await fs.writeFile(filepath, json)
+
+  if (isNew) return { changed: true, created: true }
+  return { changed: true, created: false }
+}
+
+async function main() {
+  const results = []
+
+  results.push({
+    file: SERVER_CONFIG,
+    ...(await updateConfig({
+      filepath: SERVER_CONFIG,
+      spec: PLUGIN_SPEC,
+      fallback: { $schema: "https://opencode.ai/config.json" },
+    })),
+  })
+
+  results.push({
+    file: TUI_CONFIG,
+    ...(await updateConfig({
+      filepath: TUI_CONFIG,
+      spec: PLUGIN_SPEC,
+      fallback: { $schema: "https://opencode.ai/tui.json" },
+    })),
+  })
+
+  for (const r of results) {
+    if (r.changed) {
+      const action = r.created ? "created" : "updated"
+      console.log(`[opencode-buddy] ${action} ${r.file}`)
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error("[opencode-buddy] postinstall: failed to register plugin", err.message)
+  // Don't fail the install — the user can configure manually if needed.
+  process.exit(0)
+})

package/src/tui-plugin.jsx

@@ -1,58 +1,69 @@
 /** @jsxImportSource @opentui/solid */
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule, TuiSlotPlugin } from "@opencode-ai/plugin/tui"
-import { createSignal, createMemo, onCleanup, Show, For } from "solid-js"
+import { createSignal, createMemo, onCleanup, For } from "solid-js"
 import * as persistence from "./persistence.js"
 import {
   tick as tickState,
   celebrate as celebrateState,
   scared as scaredState,
   deriveState,
+  feed,
+  play,
+  rest,
+  rename,
+  switchSpecies,
 } from "./state.js"
-import { renderFrame, frameCount, frameIntervalMs } from "./species.js"
+import { renderFrame, frameCount, frameIntervalMs, SPECIES } from "./species.js"
 
 const ANIMATION_TICK_MS = frameIntervalMs()
 const REFRESH_TICK_MS = 1500
 
-function View(props: { api: TuiPluginApi; session_id: string }) {
-  const theme = () => props.api.theme.current
-  const [state, setState] = createSignal<any | null>(null)
+function View(props) {
+  const api = props.api
+  const theme = () => api.theme.current
+  const [state, setState] = createSignal(null)
   const [frame, setFrame] = createSignal(0)
   const [lastMtime, setLastMtime] = createSignal(0)
+  const [tick, setTick] = createSignal(0)
 
   const refresh = async () => {
-    const mt = await persistence.mtime()
-    if (mt === 0) {
-      const fresh = {
-        species: "duck",
-        name: "Quack",
-        hunger: 80,
-        happiness: 80,
-        energy: 100,
-        xp: 0,
-        level: 1,
-        hatchedAt: Date.now(),
-        lastFed: Date.now(),
-        lastPlayed: Date.now(),
-        lastTick: Date.now(),
-        state: "idle",
-        stateUntil: 0,
-        stateReason: "",
+    try {
+      const mt = await persistence.mtime()
+      if (mt === 0) {
+        const fresh = {
+          species: "duck",
+          name: "Quack",
+          hunger: 80,
+          happiness: 80,
+          energy: 100,
+          xp: 0,
+          level: 1,
+          hatchedAt: Date.now(),
+          lastFed: Date.now(),
+          lastPlayed: Date.now(),
+          lastTick: Date.now(),
+          state: "idle",
+          stateUntil: 0,
+          stateReason: "",
+        }
+        await persistence.save(fresh)
+        setLastMtime(Date.now())
+        setState(fresh)
+        setTick(tick() + 1)
+        return
       }
-      await persistence.save(fresh)
-      setLastMtime(Date.now())
-      setState(fresh)
-      return
-    }
-    if (mt !== lastMtime()) {
-      setLastMtime(mt)
-      const onDisk = await persistence.load()
-      if (onDisk) {
-        const ticked = tickState(onDisk)
-        const derived = deriveState(ticked)
-        setState(derived)
-        // Persist derived state (so transient state changes survive)
-        persistence.save(derived).catch(() => {})
+      if (mt !== lastMtime()) {
+        setLastMtime(mt)
+        const onDisk = await persistence.load()
+        if (onDisk) {
+          const ticked = tickState(onDisk)
+          const derived = deriveState(ticked)
+          setState(derived)
+          setTick(tick() + 1)
+          persistence.save(derived).catch(() => {})
+        }
       }
+    } catch (err) {
+      console.error("[buddy] refresh error", err)
     }
   }
 
@@ -65,77 +76,199 @@ function View(props: { api: TuiPluginApi; session_id: string }) {
   }, ANIMATION_TICK_MS)
   onCleanup(() => clearInterval(animTimer))
 
-  const s = () => state()
-  const species = () => s()?.species ?? "duck"
-  const buddyState = () => s()?.state ?? "idle"
+  const current = state
+  const species = () => {
+    const v = current()
+    return v ? v.species : "duck"
+  }
+  const buddyState = () => {
+    const v = current()
+    return v ? v.state : "idle"
+  }
   const fc = createMemo(() => frameCount(species(), buddyState()))
   const lines = createMemo(() => renderFrame(species(), buddyState(), frame() % Math.max(1, fc())))
 
-  const bar = (v: number, color: any) => {
+  const barStr = (v) => {
     const filled = Math.round((v / 100) * 10)
-    return (
-      <text>
-        <span style={{ fg: theme().success }}>{"█".repeat(filled)}</span>
-        <span style={{ fg: theme().borderSubtle }}>{"░".repeat(10 - filled)}</span>
-      </text>
-    )
+    return "|" + "\u2588".repeat(filled) + "\u2591".repeat(10 - filled) + "|"
+  }
+
+  const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "")
+
+  const speciesColor = () => {
+    const sp = current()?.species
+    if (sp === "cat") return theme().accent
+    if (sp === "duck") return theme().success
+    if (sp === "dragon") return theme().error
+    if (sp === "axolotl") return theme().accent
+    if (sp === "robot") return theme().info
+    if (sp === "ghost") return theme().text
+    return theme().text
   }
 
   return (
-    <Show when={s()}>
-      <box flexDirection="column" paddingTop={1} paddingBottom={1}>
-        <text fg={theme().accent}>
-          <b>  {s()!.name} the {species()}</b>
-        </text>
-        <For each={lines()}>
-          {(line) => (
-            <text>
-              {"  "}
-              {line}
-            </text>
-          )}
-        </For>
-        <text fg={theme().textMuted}>  {"─".repeat(20)}</text>
-        <text>
-          {"  hunger "}
-          {bar(s()!.hunger, theme().success)}
-          {" "}
-          {Math.floor(s()!.hunger)}
-        </text>
-        <text>
-          {"  happy  "}
-          {bar(s()!.happiness, theme().accent)}
-          {" "}
-          {Math.floor(s()!.happiness)}
-        </text>
-        <text>
-          {"  energy "}
-          {bar(s()!.energy, theme().info)}
-          {" "}
-          {Math.floor(s()!.energy)}
-        </text>
-        <text fg={theme().textMuted}>
-          {"  "}
-          {buddyState()} · Lv {s()!.level} · xp {s()!.xp}/{s()!.level * 50}
-        </text>
-      </box>
-    </Show>
+    <box>
+      <text fg={theme().accent}>{current() ? current().name + " the " + current().species : "BUDDY"}</text>
+      <For each={lines()}>
+        {(line) => <text fg={speciesColor()}>{stripAnsi(line)}</text>}
+      </For>
+      <text fg={theme().textMuted}>hunger {barStr(current()?.hunger ?? 0)} {Math.floor(current()?.hunger ?? 0)}</text>
+      <text fg={theme().textMuted}>happy  {barStr(current()?.happiness ?? 0)} {Math.floor(current()?.happiness ?? 0)}</text>
+      <text fg={theme().textMuted}>energy {barStr(current()?.energy ?? 0)} {Math.floor(current()?.energy ?? 0)}</text>
+      <text fg={theme().textMuted}>{current()?.state ?? "..."}  Lv{current()?.level ?? 1}  xp{current()?.xp ?? 0}/{(current()?.level ?? 1) * 50}</text>
+    </box>
   )
 }
 
-const tui: TuiPlugin = async (api) => {
-  // Register the slot. `api` is captured in the closure so the slot
-  // function can pass it to the Solid component.
+const tui = async (api) => {
   api.slots.register({
-    order: 500,
+    order: 50,
     slots: {
       sidebar_content(_ctx, props) {
         return <View api={api} session_id={props.session_id} />
       },
     },
-  } as TuiSlotPlugin)
+  })
+
+  const feedBuddy = async () => {
+    const s = await persistence.load()
+    if (!s) return
+    const next = feed(s)
+    await persistence.save(next)
+    api.ui.toast({ variant: "success", title: "Yum!", message: `${next.name} ate a snack.` })
+  }
+  const playBuddy = async () => {
+    const s = await persistence.load()
+    if (!s) return
+    const next = play(s)
+    await persistence.save(next)
+    api.ui.toast({ variant: "success", title: "Woohoo!", message: `${next.name} played (+5xp).` })
+  }
+  const restBuddy = async () => {
+    const s = await persistence.load()
+    if (!s) return
+    const next = rest(s)
+    await persistence.save(next)
+    api.ui.toast({ variant: "info", title: "Zzz", message: `${next.name} is napping.` })
+  }
+  const statusBuddy = async () => {
+    const s = await persistence.load()
+    if (!s) return
+    api.ui.toast({
+      variant: "info",
+      title: `${s.name} the ${s.species}`,
+      message: `Lv${s.level} xp${s.xp}/${s.level * 50} - hunger ${Math.floor(s.hunger)} happy ${Math.floor(s.happiness)} energy ${Math.floor(s.energy)}`,
+    })
+  }
+  const renameBuddy = () => {
+    api.ui.dialog.replace(() => (
+      <api.ui.DialogPrompt
+        title="Rename buddy"
+        placeholder="New name (max 20 chars)"
+        onConfirm={async (value) => {
+          const s = await persistence.load()
+          if (!s) return
+          const next = rename(s, value)
+          await persistence.save(next)
+          api.ui.toast({ variant: "success", title: "Renamed", message: `Now called ${next.name}.` })
+        }}
+        onCancel={() => {}}
+      />
+    ))
+  }
+  const switchBuddy = () => {
+    const options = SPECIES.map((sp) => ({
+      title: sp,
+      value: sp,
+      onSelect: async () => {
+        const s = await persistence.load()
+        if (!s) return
+        const next = switchSpecies(s, sp)
+        await persistence.save(next)
+        api.ui.toast({ variant: "success", title: "Morphed", message: `Now a ${sp}.` })
+        api.ui.dialog.clear()
+      },
+    }))
+    api.ui.dialog.replace(() => (
+      <api.ui.DialogSelect
+        title="Switch species"
+        options={options}
+        onSelect={() => {}}
+      />
+    ))
+  }
+
+  api.keymap.registerLayer({
+    commands: [
+      {
+        namespace: "palette",
+        name: "buddy.feed",
+        title: "Feed buddy",
+        slashName: "buddy-feed",
+        category: "Buddy",
+        run() {
+          api.ui.dialog.clear()
+          void feedBuddy()
+        },
+      },
+      {
+        namespace: "palette",
+        name: "buddy.play",
+        title: "Play with buddy",
+        slashName: "buddy-play",
+        category: "Buddy",
+        run() {
+          api.ui.dialog.clear()
+          void playBuddy()
+        },
+      },
+      {
+        namespace: "palette",
+        name: "buddy.rest",
+        title: "Buddy rests",
+        slashName: "buddy-rest",
+        category: "Buddy",
+        run() {
+          api.ui.dialog.clear()
+          void restBuddy()
+        },
+      },
+      {
+        namespace: "palette",
+        name: "buddy.status",
+        title: "Show buddy status",
+        slashName: "buddy",
+        slashAliases: ["buddy-status"],
+        category: "Buddy",
+        run() {
+          api.ui.dialog.clear()
+          void statusBuddy()
+        },
+      },
+      {
+        namespace: "palette",
+        name: "buddy.rename",
+        title: "Rename buddy",
+        slashName: "buddy-rename",
+        category: "Buddy",
+        run() {
+          renameBuddy()
+        },
+      },
+      {
+        namespace: "palette",
+        name: "buddy.switch",
+        title: "Switch buddy species",
+        slashName: "buddy-switch",
+        category: "Buddy",
+        run() {
+          switchBuddy()
+        },
+      },
+    ],
+    bindings: [],
+  })
 
-  // React to opencode session events
   api.event.on("session.idle", async () => {
     const s = await persistence.load()
     if (!s) return
@@ -148,9 +281,5 @@ const tui: TuiPlugin = async (api) => {
   })
 }
 
-const plugin: TuiPluginModule & { id: string } = {
-  id: "opencode-buddy",
-  tui,
-}
-
+const plugin = { id: "opencode-buddy", tui }
 export default plugin