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

package/src/dialogs/keys.tsx

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

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

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

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

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

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

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