herm-tui 1.0.0-dev.1

package/src/dialogs/keys.tsx

@@ -0,0 +1,170 @@
+// /keys rebind dialog — list every catalog action grouped by scope, show
+// current chord + override marker + inline conflict warning. Enter opens
+// a TextPrompt for the chord spec (e.g. "ctrl+l", "<leader>m") — typing
+// the spec rather than capturing the raw keystroke sidesteps the global
+// useKeyboard ordering problem (useAppKeys would see the captured key
+// first and act on it). 'r' resets the selected row to its default.
+
+import { useState, useMemo } from "react"
+import { VBAR } from "../ui/table"
+import { useKeyboard } from "@opentui/react"
+import { useTheme } from "../theme"
+import * as prefs from "../utils/preferences"
+import {
+  useKeys, DEFAULTS, conflictsWith, parse,
+  type ActionId, type Scope, type Chord,
+} from "../keys"
+import { print as chordPrint } from "../keys/chord"
+import type { DialogContext } from "../ui/dialog"
+import { useToast } from "../ui/toast"
+import { openTextPrompt } from "./text-prompt"
+import { openConfirm } from "./confirm"
+import { loadOcKeybinds } from "../keys/oc-compat"
+
+type Group = { title: string; scope: Scope }
+
+const GROUPS: ReadonlyArray<Group> = [
+  { title: "Global",   scope: "global" },
+  { title: "Composer", scope: "composer" },
+  { title: "Lists",    scope: "list" },
+  { title: "Dialogs",  scope: "dialog" },
+  { title: "Sessions", scope: "sessions" },
+  { title: "Agents",   scope: "agents" },
+  { title: "Config",   scope: "config" },
+]
+
+type Row =
+  | { type: "header"; title: string }
+  | { type: "action"; id: ActionId; desc: string; chord: ReadonlyArray<Chord>; override: boolean }
+
+const KeysDialog = (props: { dialog: DialogContext }) => {
+  const theme = useTheme().theme
+  const keys = useKeys()
+  const toast = useToast()
+  const overrides = prefs.get("keys") ?? {}
+
+  const rows = useMemo<Row[]>(() => GROUPS.flatMap(g => {
+    const entries = keys.all(g.scope).filter(e => e.id !== "leader")
+    if (entries.length === 0) return []
+    return [
+      { type: "header" as const, title: g.title },
+      ...entries.map(e => ({
+        type: "action" as const,
+        id: e.id, desc: e.desc, chord: e.chord,
+        override: overrides[e.id] !== undefined,
+      })),
+    ]
+  }), [keys, overrides])
+
+  const actionRows = rows.map((r, i) => ({ r, i })).filter(x => x.r.type === "action")
+  const [sel, setSel] = useState(0)
+
+  const cur = actionRows[sel]?.r as Extract<Row, { type: "action" }> | undefined
+  const curConflicts = cur ? conflictsWith(keys.table, cur.id) : []
+
+  const write = (id: ActionId, value: string | undefined) => {
+    const next = { ...(prefs.get("keys") ?? {}) }
+    if (value === undefined) delete next[id]
+    else next[id] = value
+    prefs.set("keys", next)
+  }
+
+  const rebind = (id: ActionId) => {
+    const now = overrides[id] ?? DEFAULTS[id].chord
+    void openTextPrompt(props.dialog, {
+      title: `Rebind ${id}`,
+      label: "Chord (e.g. ctrl+k, <leader>m, shift+return; empty = unbind)",
+      initial: now,
+    }).then(v => {
+      // TextPrompt's dialog.clear() replaced us; remount either way.
+      openKeys(props.dialog)
+      if (v === null) return
+      const parsed = parse(v)
+      write(id, parsed.length === 0 ? "none" : v)
+    })
+  }
+
+  const importOc = () => {
+    const r = loadOcKeybinds()
+    if (r.sources.length === 0)
+      return toast.show({ variant: "info", message: "No opencode tui.json found" })
+    const n = Object.keys(r.overrides).length
+    void openConfirm(props.dialog, {
+      title: `Import ${n} keybind${n === 1 ? "" : "s"} from opencode?`,
+      body: `${r.sources.map(s => `· ${s}`).join("\n")}\n\n${n} mapped · ${r.skipped.length} skipped (no herm equivalent)${r.skipped.length ? `:\n${r.skipped.slice(0, 8).join(", ")}${r.skipped.length > 8 ? ", …" : ""}` : ""}`,
+      yes: "import",
+    }).then(ok => {
+      openKeys(props.dialog)
+      if (!ok) return
+      prefs.set("keys", { ...(prefs.get("keys") ?? {}), ...r.overrides })
+      toast.show({ variant: "success",
+        message: `Imported ${n} · skipped ${r.skipped.length}` })
+    })
+  }
+
+  useKeyboard((key) => {
+    if (key.name === "up")   return setSel(s => Math.max(0, s - 1))
+    if (key.name === "down") return setSel(s => Math.min(actionRows.length - 1, s + 1))
+    if (key.name === "return" && cur) return rebind(cur.id)
+    if (key.name === "r" && !key.ctrl && cur?.override) { write(cur.id, undefined); return }
+    if (key.name === "o" && !key.ctrl) return importOc()
+  })
+
+  return (
+    <box flexDirection="column" width={78}>
+      <box height={1} flexDirection="row">
+        <box flexGrow={1}><text fg={theme.text}><strong>Keybindings</strong></text></box>
+        <text fg={theme.textMuted}>{`leader = ${keys.print("leader")}`}</text>
+      </box>
+      <box height={1} />
+      <scrollbox scrollY maxHeight={22} verticalScrollbarOptions={VBAR}>
+        <box flexDirection="column" width="100%">
+          {rows.map((r, i) => {
+            if (r.type === "header") return (
+              <box key={`h-${r.title}`} height={1} marginTop={i > 0 ? 1 : 0}>
+                <text fg={theme.primary}><strong>{r.title}</strong></text>
+              </box>
+            )
+            const ai = actionRows.findIndex(x => x.i === i)
+            const on = ai === sel
+            const conf = conflictsWith(keys.table, r.id)
+            return (
+              <box key={r.id} height={1} flexDirection="row"
+                   backgroundColor={on ? theme.backgroundElement : undefined}
+                   onMouseOver={() => setSel(ai)}
+                   onMouseDown={() => { setSel(ai); rebind(r.id) }}>
+                <box width={2} flexShrink={0}>
+                  <text fg={on ? theme.primary : theme.text}>{on ? "▸ " : "  "}</text>
+                </box>
+                <box width={16} flexShrink={0} height={1} overflow="hidden">
+                  <text fg={on ? theme.accent : theme.text}>
+                    {chordPrint(r.chord, keys.print("leader")) || "—"}
+                  </text>
+                </box>
+                <box flexGrow={1} minWidth={0} height={1} overflow="hidden">
+                  <text fg={theme.textMuted}>{r.desc}</text>
+                </box>
+                <box width={5} flexShrink={0} flexDirection="row" justifyContent="flex-end">
+                  <text>
+                    {r.override ? <span fg={theme.info}>{"· "}</span> : null}
+                    {conf.length > 0 ? <span fg={theme.warning}>⚠</span> : null}
+                  </text>
+                </box>
+              </box>
+            )
+          })}
+        </box>
+      </scrollbox>
+      <box height={1} />
+      <box height={1}>
+        {curConflicts.length > 0
+          ? <text fg={theme.warning}>{`⚠ shares ${keys.print(cur!.id)} with: ${curConflicts.join(", ")}`}</text>
+          : <text fg={theme.textMuted}>{`↑↓ select  Enter rebind${cur?.override ? "  ·  r reset" : ""}  ·  o import opencode  ·  esc close  ·  · = overridden`}</text>}
+      </box>
+    </box>
+  )
+}
+
+export function openKeys(dialog: DialogContext) {
+  dialog.replace(<KeysDialog dialog={dialog} />)
+}

package/src/dialogs/logs.tsx

@@ -0,0 +1,42 @@
+// Gateway subprocess stderr tail — everything GatewayClient.log() captured
+// (stderr lines, protocol errors, startup-timeout markers). The ring
+// buffer holds the last ~200 lines regardless of what the transcript
+// chose to surface.
+
+import { useTheme } from "../theme"
+import { useGateway } from "../app/gateway"
+import { useDialog } from "../ui/dialog"
+
+const ERRLIKE = /error|fail|traceback|exception|\b[45]\d\d\b|refused|denied|unauthori/i
+
+const LogsDialog = () => {
+  const theme = useTheme().theme
+  const gw = useGateway()
+  const lines = gw.tail(200).split("\n").filter(Boolean)
+
+  return (
+    <box flexDirection="column" width={110} height={Math.min(34, Math.max(8, lines.length + 5))}>
+      <box height={1}><text fg={theme.primary}><strong>Gateway Logs</strong></text></box>
+      <box height={1}><text fg={theme.textMuted}>{lines.length} lines · stderr + protocol · Esc to close</text></box>
+      <box height={1} />
+      {lines.length === 0 ? (
+        <box height={1}><text fg={theme.textMuted}>No log output captured.</text></box>
+      ) : (
+        <scrollbox scrollY stickyScroll stickyStart="bottom" flexGrow={1}>
+          <box flexDirection="column">
+            {lines.map((l, i) => (
+              <box key={i} height={1}>
+                <text fg={ERRLIKE.test(l) ? theme.error : theme.textMuted}>
+                  {l.length > 106 ? l.slice(0, 105) + "…" : l}
+                </text>
+              </box>
+            ))}
+          </box>
+        </scrollbox>
+      )}
+    </box>
+  )
+}
+
+export const openLogs = (dialog: ReturnType<typeof useDialog>) =>
+  dialog.replace(<LogsDialog />)

package/src/dialogs/message.tsx

@@ -0,0 +1,38 @@
+// Per-message action menu — oc routes/session/dialog-message.tsx.
+// Opened by clicking a user message. Copy is local; Rewind and Fork
+// delegate to callbacks owned by app.tsx (they need turn state +
+// gateway + composer).
+
+import { DialogSelect } from "../ui/dialog-select"
+import type { DialogContext } from "../ui/dialog"
+import type { Message } from "../types/message"
+import { copy } from "../utils/clipboard"
+
+export type MessageOps = {
+  rewind: (m: Message) => void
+  fork: (m: Message) => void
+}
+
+export function openMessage(dialog: DialogContext, m: Message, ops: MessageOps) {
+  const text = m.parts
+    .filter(p => p.type === "text")
+    .map(p => p.content)
+    .join("")
+
+  dialog.replace(
+    <DialogSelect
+      title="Message Actions"
+      options={[
+        { title: "Copy", value: "copy", description: "message text to clipboard" },
+        { title: "Rewind here", value: "rewind", description: "undo back to this turn (destructive)" },
+        { title: "Fork here", value: "fork", description: "branch a new session at this point" },
+      ]}
+      onSelect={(o) => {
+        dialog.clear()
+        if (o.value === "copy") return void copy(text)
+        if (o.value === "rewind") return ops.rewind(m)
+        if (o.value === "fork") return ops.fork(m)
+      }}
+    />,
+  )
+}

package/src/dialogs/model-picker.tsx

@@ -0,0 +1,123 @@
+// Pick provider → model. Default scope is the *current session* (the
+// gateway applies the switch to the live agent when `session_id` is
+// passed); Tab toggles to global persist. The gateway's `config.set`
+// accepts a single space-separated arg string with `--provider` /
+// `--global` flags (same grammar as the `/model` slash command) and
+// routes through `_apply_model_switch`, so we send one request rather
+// than a provider/model pair.
+
+import { useEffect, useState, useCallback } from "react"
+import { useDialog } from "../ui/dialog"
+import { DialogSelect, type SelectOption } from "../ui/dialog-select"
+import { useTheme } from "../theme"
+import { useToast } from "../ui/toast"
+import type { Gateway } from "../app/gateway"
+import type { ConfigSetResponse, ModelOptionsResponse } from "../utils/gateway-types"
+
+type Step = "provider" | "model"
+
+type Props = {
+  gw: Gateway
+  /** Override the default "switch this session / global" apply. When
+   *  set, the scope toggle is hidden and the caller owns the write. */
+  onApply?: (provider: string, model: string) => Promise<void>
+  title?: string
+}
+
+const ModelPickerDialog = (props: Props) => {
+  const dialog = useDialog()
+  const toast = useToast()
+  const theme = useTheme().theme
+  const [data, setData] = useState<ModelOptionsResponse | null>(null)
+  const [step, setStep] = useState<Step>("provider")
+  const [provider, setProvider] = useState<string | null>(null)
+  const [global, setGlobal] = useState(false)
+
+  useEffect(() => {
+    props.gw.request<ModelOptionsResponse>("model.options")
+      .then(setData)
+      .catch(() => setData({ providers: [] }))
+  }, [props.gw])
+
+  const apply = useCallback((model: string, prov: string) => {
+    if (props.onApply) return void props.onApply(prov, model)
+      .catch((e: Error) => toast.show({ variant: "error", message: e.message }))
+    const value = `${model} --provider ${prov}${global ? " --global" : ""}`
+    props.gw.request<ConfigSetResponse>("config.set", global
+      ? { key: "model", value, session_id: undefined }
+      : { key: "model", value })
+      .then(r => {
+        toast.show({ variant: "success", message: `model → ${r.value ?? model}${global ? " (global)" : ""}` })
+        if (r.warning) toast.show({ variant: "warning", message: r.warning })
+      })
+      .catch((e: Error) => toast.show({ variant: "error", message: e.message }))
+  }, [props.gw, props.onApply, global, toast])
+
+  const onKey = useCallback((k: { name: string }) => {
+    if (k.name === "tab" && !props.onApply) { setGlobal(g => !g); return true }
+    if (k.name === "left" && step === "model") { setStep("provider"); return true }
+    return false
+  }, [step, props.onApply])
+
+  const footer = props.onApply
+    ? <text fg={theme.textMuted}>{step === "model" ? "←: providers" : " "}</text>
+    : (
+      <text fg={theme.textMuted}>
+        <span>Scope: </span>
+        <span fg={global ? theme.warning : theme.accent}>
+          {global ? "global (persists to config)" : "this session"}
+        </span>
+        <span> · Tab: toggle{step === "model" ? " · ←: providers" : ""}</span>
+      </text>
+    )
+
+  if (!data) return <box width={50} padding={1}><text>Loading models…</text></box>
+
+  if (step === "provider") {
+    const options: SelectOption[] = (data.providers ?? []).map(p => ({
+      title: p.name,
+      value: p.slug,
+      description: p.total_models ? `${p.total_models} models` : undefined,
+      category: p.is_current ? "Current" : "Available",
+    }))
+    return (
+      <DialogSelect
+        title={props.title ?? "Switch Provider"}
+        options={options}
+        current={data.provider}
+        onSelect={(o) => { setProvider(o.value); setStep("model") }}
+        onKey={onKey}
+        placeholder="Search providers..."
+        footer={footer}
+      />
+    )
+  }
+
+  const p = data.providers?.find(pp => pp.slug === provider)
+  const options: SelectOption[] = (p?.models ?? []).map(m => ({
+    title: m,
+    value: m,
+  }))
+
+  return (
+    <DialogSelect
+      title={props.title ? `${props.title} · ${p?.name ?? provider}` : `Switch Model (${p?.name ?? provider})`}
+      options={options}
+      current={data.model}
+      onSelect={(o) => {
+        if (provider) apply(o.value, provider)
+        dialog.clear()
+      }}
+      onKey={onKey}
+      placeholder="Search models..."
+      footer={footer}
+    />
+  )
+}
+
+export const openModelPicker = (
+  dialog: ReturnType<typeof useDialog>, gw: Gateway,
+  opts?: { title?: string; onApply?: (provider: string, model: string) => Promise<void> },
+) => {
+  dialog.replace(<ModelPickerDialog gw={gw} title={opts?.title} onApply={opts?.onApply} />)
+}

package/src/dialogs/new-profile.tsx

@@ -0,0 +1,69 @@
+import { useState } from "react"
+import { useKeyboard } from "@opentui/react"
+import { useTheme } from "../theme"
+import { validateName } from "../utils/hermes-profiles"
+import type { DialogContext } from "../ui/dialog"
+
+type Result = { name: string; cloneFrom: string | null; alias: boolean }
+
+export function openCreateProfile(dialog: DialogContext, opts: { existing: string[] }): Promise<Result | null> {
+  return new Promise(resolve => {
+    const done = (r: Result | null) => { dialog.clear(); resolve(r) }
+    dialog.replace(<Form existing={opts.existing} done={done} />)
+  })
+}
+
+const Form = ({ existing, done }: { existing: string[]; done: (r: Result | null) => void }) => {
+  const theme = useTheme().theme
+  const [name, setName] = useState("")
+  const [cloneIdx, setCloneIdx] = useState(0)
+  const [alias, setAlias] = useState(true)
+  const options = ["(fresh)", ...existing]
+  const err = name ? validateName(name, existing) : null
+  const valid = !!name && !err
+
+  useKeyboard((key) => {
+    if (key.name === "escape") return done(null)
+    if (key.name === "return") {
+      if (!valid) return
+      return done({ name, cloneFrom: cloneIdx === 0 ? null : options[cloneIdx], alias })
+    }
+    if (key.name === "up") return setCloneIdx(i => Math.max(0, i - 1))
+    if (key.name === "down") return setCloneIdx(i => Math.min(options.length - 1, i + 1))
+    if (key.name === "tab") return setAlias(a => !a)
+    if (key.name === "backspace") return setName(n => n.slice(0, -1))
+    if (key.raw && key.raw.length === 1 && /[a-z0-9_-]/.test(key.raw))
+      return setName(n => n + key.raw)
+  })
+
+  return (
+    <box flexDirection="column" width={54}>
+      <box height={1}><text fg={theme.primary}><strong>New Profile</strong></text></box>
+      <box height={1} />
+      <box height={1} flexDirection="row">
+        <box width={11}><text fg={theme.textMuted}>Name</text></box>
+        <text>
+          <span fg={valid || !name ? theme.text : theme.error}>{name}</span>
+          <span fg={theme.accent}>█</span>
+        </text>
+      </box>
+      <box height={1}><text fg={theme.textMuted}>  a-z 0-9 _ -  ·  lowercase</text></box>
+      <box height={1} />
+      <box height={1}><text fg={theme.textMuted}>Clone from  (↑↓)</text></box>
+      {options.map((o, i) => (
+        <box key={o} height={1}>
+          <text fg={i === cloneIdx ? theme.accent : theme.text}>
+            {i === cloneIdx ? "▸ " : "  "}{o}
+          </text>
+        </box>
+      ))}
+      <box height={1} />
+      <box height={1}><text fg={theme.textMuted}>
+        {`[Tab] shell alias: ${alias ? "yes" : "no"}`}
+      </text></box>
+      <box height={1}><text fg={theme.textMuted}>
+        {valid ? "Enter create  ·  Esc cancel" : err ?? "type a name"}
+      </text></box>
+    </box>
+  )
+}

package/src/dialogs/new-task.tsx

@@ -0,0 +1,103 @@
+// Create/edit a kanban task. Tab cycles fields; ↑↓ pick assignee or
+// bump priority depending on focused field; Enter submits when title
+// is non-empty. Body is single-line here — longer specs go in as a
+// follow-up comment (c) from the board.
+
+import { useState } from "react"
+import { useKeyboard } from "@opentui/react"
+import { useTheme } from "../theme"
+import type { DialogContext } from "../ui/dialog"
+
+export type Draft = {
+  title: string; body: string; assignee: string | null
+  priority: number; parent: string | null
+}
+
+type Field = "title" | "body" | "assignee" | "priority"
+const ORDER: Field[] = ["title", "body", "assignee", "priority"]
+
+export function openCreateTask(
+  dialog: DialogContext,
+  opts: { assignees: string[]; parent?: { id: string; title: string } },
+): Promise<Draft | null> {
+  return new Promise(resolve => {
+    const done = (r: Draft | null) => { dialog.clear(); resolve(r) }
+    dialog.replace(<Form pool={opts.assignees} parent={opts.parent} done={done} />)
+  })
+}
+
+const Form = (p: {
+  pool: string[]; parent?: { id: string; title: string }; done: (r: Draft | null) => void
+}) => {
+  const theme = useTheme().theme
+  const pool = ["(unassigned)", ...p.pool]
+  const [field, setField] = useState<Field>("title")
+  const [title, setTitle] = useState("")
+  const [body, setBody] = useState("")
+  const [who, setWho] = useState(0)
+  const [pri, setPri] = useState(0)
+  const valid = title.trim().length > 0
+
+  const edit = (fn: (s: string) => string) =>
+    field === "title" ? setTitle(fn) : setBody(fn)
+
+  useKeyboard((key) => {
+    if (key.name === "escape") return p.done(null)
+    if (key.name === "return") {
+      if (!valid) return
+      return p.done({
+        title: title.trim(), body: body.trim(),
+        assignee: who === 0 ? null : pool[who],
+        priority: pri, parent: p.parent?.id ?? null,
+      })
+    }
+    if (key.name === "tab") {
+      const i = ORDER.indexOf(field)
+      return setField(ORDER[(i + (key.shift ? ORDER.length - 1 : 1)) % ORDER.length])
+    }
+    if (key.name === "up" || key.name === "down") {
+      const d = key.name === "up" ? -1 : 1
+      if (field === "priority") return setPri(n => Math.max(0, Math.min(9, n + d)))
+      return setWho(i => (i + d + pool.length) % pool.length)
+    }
+    if (field === "title" || field === "body") {
+      if (key.name === "backspace") return edit(s => s.slice(0, -1))
+      if (key.ctrl && key.name === "u") return edit(() => "")
+      if (!key.ctrl && !key.meta && key.raw && key.raw.length === 1 && key.raw >= " ")
+        return edit(s => s + key.raw)
+    }
+  })
+
+  const row = (f: Field, label: string, val: string) => (
+    <box height={1} flexDirection="row">
+      <box width={11}><text fg={field === f ? theme.accent : theme.textMuted}>
+        {field === f ? "▸ " : "  "}{label}
+      </text></box>
+      <box flexGrow={1} minWidth={0} height={1} overflow="hidden">
+        <text>
+          <span fg={theme.text}>{val}</span>
+          {field === f && (f === "title" || f === "body")
+            ? <span fg={theme.accent}>█</span> : null}
+        </text>
+      </box>
+    </box>
+  )
+
+  return (
+    <box flexDirection="column" width={64}>
+      <box height={1}><text fg={theme.primary}>
+        <strong>{p.parent ? `New Task  ·  child of ${p.parent.id}` : "New Task"}</strong>
+      </text></box>
+      {p.parent ? <box height={1}><text fg={theme.textMuted}>  {p.parent.title}</text></box> : null}
+      <box height={1} />
+      {row("title", "Title", title)}
+      {row("body", "Body", body || "—")}
+      {row("assignee", "Assignee", pool[who])}
+      {row("priority", "Priority", pri ? `P${pri}` : "—")}
+      <box height={1} />
+      <box height={1}><text fg={theme.textMuted}>
+        {valid ? "Enter create  ·  Tab field  ·  ↑↓ pick  ·  Esc cancel" : "type a title  ·  Tab field"}
+      </text></box>
+    </box>
+  )
+}

package/src/dialogs/profile.tsx

@@ -0,0 +1,55 @@
+// Per-profile action menu. All mutations route through the hermes CLI
+// via `shell.exec` so herm doesn't duplicate validation/cleanup logic.
+// "Open …" actions use the OS handler (openFile) rather than an
+// in-TUI editor — SOUL.md and config.yaml are multi-hundred-line
+// files, not composer-sized inputs.
+
+import { DialogSelect, type SelectOption } from "../ui/dialog-select"
+import type { DialogContext } from "../ui/dialog"
+import type { ProfileInfo } from "../utils/hermes-profiles"
+import { openFile } from "../utils/open-file"
+
+export type ProfileOps = {
+  sticky: (p: ProfileInfo) => void
+  unsticky: () => void
+  export: (p: ProfileInfo) => void
+  remove: (p: ProfileInfo) => void
+}
+
+export function openProfileMenu(dialog: DialogContext, p: ProfileInfo, ops: ProfileOps) {
+  const opts: SelectOption[] = [
+    { category: "Open", value: "soul", title: "SOUL.md", description: "edit persona/system prompt" },
+    { category: "Open", value: "config", title: "config.yaml", description: "model, provider, toolsets" },
+    ...(p.has_env
+      ? [{ category: "Open", value: "env", title: ".env", description: "API keys + secrets" }] : []),
+    { category: "Open", value: "dir", title: "Directory", description: p.path },
+    ...(p.is_sticky
+      ? [{ category: "Default", value: "unsticky", title: "Clear sticky default",
+           description: "hermes profile use --clear" }]
+      : [{ category: "Default", value: "sticky", title: "Set as sticky default",
+           description: `hermes profile use ${p.name}` }]),
+    { category: "Manage", value: "export", title: "Export",
+      description: `hermes profile export ${p.name}` },
+    ...(p.is_default || p.is_active ? []
+      : [{ category: "Manage", value: "delete", title: "Delete",
+           description: "irreversible — removes config, env, memory, sessions" }]),
+  ]
+
+  dialog.replace(
+    <DialogSelect
+      title={`Profile · ${p.name}${p.is_active ? " (active)" : ""}`}
+      options={opts}
+      onSelect={(o) => {
+        dialog.clear()
+        if (o.value === "soul") return openFile(p.sources.soul.file)
+        if (o.value === "config") return openFile(p.sources.config.file)
+        if (o.value === "env") return openFile(p.sources.env.file)
+        if (o.value === "dir") return openFile(p.path)
+        if (o.value === "sticky") return ops.sticky(p)
+        if (o.value === "unsticky") return ops.unsticky()
+        if (o.value === "export") return ops.export(p)
+        if (o.value === "delete") return ops.remove(p)
+      }}
+    />,
+  )
+}