herm-tui 1.0.0-dev.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 liftaris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# Herm - Dashboard TUI for Hermes
+<img width="1711" height="927" alt="image" src="https://github.com/user-attachments/assets/d3b855a0-b1b2-4ea1-8eab-84f9716c8de9" />
+
+> **herm** /hɜːm/ _noun_ : a sculptured head of Hermes on a square stone pillar, used in ancient Greece as a boundary marker at crossroads.
+
+Herm is a tabbed, mouse-aware TUI built with [OpenTUI](https://github.com/anomalyco/opentui) (React renderer) and [Bun](https://bun.sh/). It talks to the same gateway `hermes` cli uses.
+
+## What it does
+
+- **Chat** with streaming, markdown, code blocks, diff rendering, tool-call expansion, and an animated ASCII avatar
+- **Tabs** for sessions, context, agents, skills, cron, toolsets, memory, env, config
+- **Command palette** (`Ctrl+K`), **slash popover**, **@-refs** for file/diff context
+- **Fully rebindable keys** (`/keys`) and theme picker
+
+## Install
+
+Herm needs a working [Hermes Agent](https://github.com/NousResearch/hermes-agent) install and [Bun](https://bun.sh).
+
+```bash
+bun add -g herm-tui        # stable
+bun add -g herm-tui@next   # bleeding edge (every dev push)
+herm
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/liftaris/herm.git
+cd herm && bun install
+bun run src/index.tsx
+```
+
+Herm looks for `~/.hermes`. If yours lives elsewhere, set `HERMES_HOME`. See [`.env.example`](./.env.example) for rarely-needed overrides.
+
+## Development
+
+```bash
+bun run dev            # watch mode
+bun run typecheck
+bun test
+```
+
+## Motivation
+Before Hermes, OpenCode was my daily driver. I built Herm because I wanted Hermes capabilities with an OpenCode style interface. Herm uses the same TUI framework OpenCode is built with, OpenTUI, and also exposes dashboard style tabs that centralizes everything I need to do in Hermes in my interface of choice--the terminal.
+
+## Acknowledgments
+
+- [Hermes Agent](https://github.com/NousResearch/hermes-agent) — the brain
+- [OpenTUI](https://github.com/anomalyco/opentui) — the TUI framework
+- [OpenCode](https://github.com/anomalyco/opencode) — the inspiration
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "herm-tui",
+  "version": "1.0.0-dev.1",
+  "description": "A modern TUI for Hermes Agent",
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/liftaris/herm.git"
+  },
+  "homepage": "https://github.com/liftaris/herm#readme",
+  "bugs": {
+    "url": "https://github.com/liftaris/herm/issues"
+  },
+  "bin": {
+    "herm": "src/index.tsx"
+  },
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.*",
+    "scripts/postinstall.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "bun run --watch src/index.tsx",
+    "dev:perf": "PERF=1 bun run --watch src/index.tsx",
+    "dev:perf:verbose": "PERF=verbose bun run --watch src/index.tsx",
+    "dev:smol": "bun --smol run --watch src/index.tsx",
+    "dev:profile": "bun --cpu-prof --cpu-prof-dir=./profiles run src/index.tsx",
+    "dev:heap": "bun --heap-prof --heap-prof-dir=./profiles run src/index.tsx",
+    "dev:control": "CONTROL=1 bun run --watch src/index.tsx",
+    "dev:full": "PERF=1 CONTROL=1 bun run --watch src/index.tsx",
+    "gen-schema": "bun scripts/gen-schema.ts",
+    "showcase": "scripts/showcase/record.sh",
+    "build": "bun scripts/gen-schema.ts && bun build src/index.tsx node_modules/@opentui/core/parser.worker.js scripts/parser-worker-shim.ts --target=bun --outdir=dist --minify --entry-naming='[name].[ext]' && mv dist/parser-worker-shim.js dist/parser.worker.shim.js && test -f dist/parser.worker.js && test -f dist/parser.worker.shim.js",
+    "start": "bun run dist/index.js",
+    "test": "bun test",
+    "typecheck": "bunx tsc --noEmit",
+    "postinstall": "bun run scripts/postinstall.ts"
+  },
+  "dependencies": {
+    "@opentui/core": "0.1.99",
+    "@opentui/react": "0.1.99",
+    "gpt-tokenizer": "^3.4.0",
+    "open": "^11.0.0",
+    "react": "^19.2.5",
+    "web-tree-sitter": "0.25.10",
+    "yaml": "^2.8.3"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/bun": "1.3.13",
+    "@types/react": "^19.2.14",
+    "semantic-release": "^25.0.3",
+    "typescript": "^5.8.2"
+  },
+  "overrides": {
+    "three": "npm:empty-npm-package@1.0.0",
+    "planck": "npm:empty-npm-package@1.0.0",
+    "bun-webgpu": "npm:empty-npm-package@1.0.0",
+    "@dimforge/rapier2d-simd-compat": "npm:empty-npm-package@1.0.0",
+    "jimp": "npm:empty-npm-package@1.0.0",
+    "@jimp/core": "npm:empty-npm-package@1.0.0",
+    "@jimp/js-bmp": "npm:empty-npm-package@1.0.0",
+    "@jimp/js-gif": "npm:empty-npm-package@1.0.0",
+    "@jimp/js-jpeg": "npm:empty-npm-package@1.0.0",
+    "@jimp/js-png": "npm:empty-npm-package@1.0.0",
+    "@jimp/js-tiff": "npm:empty-npm-package@1.0.0",
+    "@jimp/plugin-resize": "npm:empty-npm-package@1.0.0",
+    "@jimp/types": "npm:empty-npm-package@1.0.0",
+    "@jimp/utils": "npm:empty-npm-package@1.0.0"
+  }
+}

package/scripts/postinstall.ts

@@ -0,0 +1,29 @@
+/**
+ * postinstall — stub out heavy optional dependencies that @opentui/core
+ * and @opentui/react pull in but Herm never uses.
+ *
+ * react-devtools-core is imported statically by @opentui/react, so it needs
+ * a real module that exports the expected API shape (not just an empty package).
+ */
+import { mkdirSync, writeFileSync, existsSync } from "fs"
+import { join } from "path"
+
+const nm = join(import.meta.dir, "..", "node_modules")
+
+// Stub react-devtools-core with noop exports
+const rdcDir = join(nm, "react-devtools-core")
+if (!existsSync(rdcDir)) {
+  mkdirSync(rdcDir, { recursive: true })
+  writeFileSync(
+    join(rdcDir, "package.json"),
+    JSON.stringify({ name: "react-devtools-core", version: "0.0.0", main: "index.js" })
+  )
+  writeFileSync(
+    join(rdcDir, "index.js"),
+    [
+      "const noop = () => {};",
+      "module.exports = { initialize: noop, connectToDevTools: noop };",
+      "module.exports.default = module.exports;",
+    ].join("\n")
+  )
+}

package/src/app/gateway.tsx

@@ -0,0 +1,83 @@
+// GatewayClient exposed via React context. The provider accepts an
+// injected client so tests can substitute a MockGateway without
+// spawning the Python tui_gateway subprocess.
+
+import { createContext, useContext, useEffect, useRef, useState, useMemo } from "react"
+import type { ReactNode } from "react"
+import { EventEmitter } from "events"
+import { GatewayClient } from "../utils/gateway-client"
+import type { GatewayEvent } from "../utils/gateway-types"
+
+/** Minimal surface consumers depend on. GatewayClient satisfies this. */
+export interface Gateway extends EventEmitter {
+  request<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T>
+  setSession(sid: string): void
+  start(): void
+  drain(): void
+  kill(): void
+  tail(n?: number): string
+  readonly ready: boolean
+}
+
+type Ctx = {
+  client: Gateway
+  ready: boolean
+}
+
+const Gw = createContext<Ctx | null>(null)
+
+export const GatewayProvider = ({ client, children }: { client?: Gateway; children: ReactNode }) => {
+  const ref = useRef<Gateway | null>(null)
+  if (!ref.current) ref.current = client ?? new GatewayClient()
+  const [ready, setReady] = useState(ref.current.ready)
+
+  useEffect(() => {
+    const c = ref.current!
+    const onEvent = (ev: GatewayEvent) => {
+      if (ev.type === "gateway.ready" || ev.type === "session.info") setReady(true)
+    }
+    c.on("event", onEvent)
+    c.start()
+    c.drain()
+    return () => {
+      c.off("event", onEvent)
+      c.removeAllListeners()
+      c.kill()
+    }
+  }, [])
+
+  const value = useMemo<Ctx>(() => ({ client: ref.current!, ready }), [ready])
+  return <Gw.Provider value={value}>{children}</Gw.Provider>
+}
+
+export function useGateway(): Gateway {
+  const ctx = useContext(Gw)
+  if (!ctx) throw new Error("useGateway() must be inside <GatewayProvider>")
+  return ctx.client
+}
+
+/**
+ * Subscribe to all gateway events. The first subscription drains any
+ * events buffered before React mounted, so nothing is lost between
+ * `client.start()` and component wiring.
+ */
+export function useGatewayEvent(handler: (ev: GatewayEvent) => void): void {
+  const ctx = useContext(Gw)
+  if (!ctx) throw new Error("useGatewayEvent() must be inside <GatewayProvider>")
+  const ref = useRef(handler)
+  ref.current = handler
+  useEffect(() => {
+    const c = ctx.client
+    const fn = (ev: GatewayEvent) => ref.current(ev)
+    c.on("event", fn)
+    c.drain()
+    return () => { c.off("event", fn) }
+  }, [ctx.client])
+}
+
+/** True once gateway.ready or session.info has fired. */
+export function useGatewayReady(): boolean {
+  const ctx = useContext(Gw)
+  if (!ctx) throw new Error("useGatewayReady() must be inside <GatewayProvider>")
+  return ctx.ready
+}

package/src/app/gatewayEvents.ts

@@ -0,0 +1,203 @@
+// Maps a GatewayEvent to a turn-reducer Action plus fire-and-forget side effects.
+
+import * as perf from "../utils/perf"
+import * as spawnHistory from "./spawnHistory"
+import type { GatewayEvent, GatewaySkin, SessionInfo } from "../utils/gateway-types"
+import type { Action } from "./turnReducer"
+import { pid, type Usage } from "../types/message"
+
+export type Side = {
+  onReady?: () => void
+  onSessionInfo?: (info: SessionInfo) => void
+  onUsage?: (u: Usage) => void
+  onTurnComplete?: () => void
+  onBackground?: (task_id: string, text: string) => void
+  onBtw?: (text: string) => void
+  onStatus?: (text: string) => void
+  onSkin?: (skin: GatewaySkin | null | undefined) => void
+}
+
+function count(o: Record<string, string[]> | undefined): number {
+  return o ? Object.values(o).reduce((n, v) => n + v.length, 0) : 0
+}
+
+export function mapEvent(ev: GatewayEvent, side: Side): Action | null {
+  switch (ev.type) {
+    case "gateway.ready":
+      side.onReady?.()
+      if (ev.payload?.skin) side.onSkin?.(ev.payload.skin)
+      return null
+
+    case "session.info": {
+      const si = ev.payload
+      side.onSessionInfo?.(si)
+      const label = si.model
+        ? `Connected — ${si.model} · ${count(si.tools)} tools · ${count(si.skills)} skills`
+        : "Connected to Hermes"
+      if (si.credential_warning) side.onStatus?.(si.credential_warning)
+      return { kind: "system", text: label }
+    }
+
+    case "message.start":
+      perf.count("stream:start")
+      perf.mem("stream-start")
+      return { kind: "message.start" }
+
+    case "message.delta": {
+      const chunk = ev.payload?.text ?? ""
+      if (!chunk) return null
+      perf.count("stream:chunk")
+      return { kind: "message.delta", chunk }
+    }
+
+    case "message.complete": {
+      perf.count("stream:done")
+      perf.mem("stream-done")
+      const p = ev.payload
+      if (p?.usage) side.onUsage?.(p.usage)
+      side.onTurnComplete?.()
+      // The gateway reports in-agent failures via status (exceptions come
+      // as a separate `error` event). Without this branch a failed API
+      // call ends the turn with no visible output.
+      if (p?.status === "error")
+        return { kind: "error", text: p.text || "request failed — see messages above" }
+      if (p?.status === "interrupted")
+        return { kind: "message.complete", text: (p.text || "") + "\n\n*[interrupted]*", usage: p?.usage }
+      return { kind: "message.complete", text: p?.text ?? undefined, usage: p?.usage }
+    }
+
+    case "tool.start":
+      return {
+        kind: "tool.start",
+        id: ev.payload.tool_id,
+        name: ev.payload.name ?? "unknown",
+        preview: ev.payload.context,
+      }
+
+    case "tool.progress":
+      return { kind: "tool.progress", name: ev.payload.name, preview: ev.payload.preview }
+
+    case "tool.generating":
+      return { kind: "tool.generating", name: ev.payload.name }
+
+    case "tool.complete":
+      return {
+        kind: "tool.complete",
+        id: ev.payload.tool_id,
+        summary: ev.payload.summary,
+        error: ev.payload.error,
+        inline_diff: ev.payload.inline_diff,
+      }
+
+    case "thinking.delta":
+      // Cosmetic spinner text from the agent's status line, not model
+      // reasoning. Surface as transient status only.
+      side.onStatus?.(ev.payload?.text ?? "")
+      return null
+
+    case "reasoning.delta":
+    case "reasoning.available": {
+      const text = ev.payload?.text
+      if (!text) return null
+      return { kind: "thinking", text, final: ev.type === "reasoning.available" }
+    }
+
+    case "subagent.start":
+    case "subagent.thinking":
+    case "subagent.tool":
+    case "subagent.progress":
+    case "subagent.complete": {
+      const sub = ev.type.slice(9) as "start" | "thinking" | "tool" | "progress" | "complete"
+      // Feed the turn-wide accumulator so the completed tree can be
+      // persisted (spawn_tree.save) and the Agents tab can read live
+      // tool trails without its own event listener.
+      spawnHistory.record(sub, ev.payload)
+      return { kind: "subagent", event: sub, payload: ev.payload }
+    }
+
+    case "error":
+      return { kind: "error", text: ev.payload?.message ?? "Unknown error" }
+
+    case "clarify.request":
+      return { kind: "prompt", id: ev.payload.request_id,
+               req: { variant: "clarify", ...ev.payload } }
+
+    case "approval.request":
+      // Approval has no request_id upstream — the gateway's approval
+      // responder is a single pending slot. Mint a unique part id so
+      // multiple approvals in one turn don't alias each other when
+      // prompt.answered updates by id.
+      return { kind: "prompt", id: `approval-${pid()}`,
+               req: { variant: "approval", ...ev.payload } }
+
+    case "sudo.request":
+      return { kind: "prompt", id: ev.payload.request_id,
+               req: { variant: "sudo", ...ev.payload } }
+
+    case "secret.request":
+      return { kind: "prompt", id: ev.payload.request_id,
+               req: { variant: "secret", ...ev.payload } }
+
+    case "background.complete":
+      side.onBackground?.(ev.payload.task_id, ev.payload.text)
+      return null
+
+    case "review.summary": {
+      // Self-improvement background review saved a skill patch or
+      // memory entry. Upstream tui_gateway emits this so clients can
+      // surface the mutation — without it, the file change happens
+      // silently. Python side already formats the text with a 💾
+      // prefix, so we pass through verbatim (trimmed). Guard blank
+      // payloads: upstream does the same, and a blank system line is
+      // noise. No toast — these fire stochastically post-turn and
+      // per-event toasting would spam.
+      const text = String(ev.payload?.text ?? "").trim()
+      if (!text) return null
+      return { kind: "system", text }
+    }
+
+    case "btw.complete":
+      side.onBtw?.(ev.payload.text)
+      return null
+
+    case "gateway.stderr": {
+      // Error-ish stderr lines (tracebacks, HTTP 4xx/5xx, auth failures)
+      // surface inline; benign chatter stays in gw.tail() only (/logs).
+      const line = ev.payload.line
+      if (/error|fail|traceback|exception|\b[45]\d\d\b|refused|denied|unauthori/i.test(line))
+        return { kind: "system", text: line.slice(0, 200) }
+      return null
+    }
+
+    case "skin.changed":
+      side.onSkin?.(ev.payload)
+      return null
+
+    case "gateway.start_timeout":
+      return { kind: "error", text: `gateway startup timed out (${ev.payload?.python ?? "python"} @ ${ev.payload?.cwd ?? "?"})` }
+
+    case "gateway.protocol_error":
+      return { kind: "system", text: `protocol error: ${ev.payload?.preview ?? "?"}` }
+
+    case "browser.progress": {
+      // Streamed during /browser connect (upstream e75082901). Surface as
+      // transcript rows so long CDP attach work isn't a 60s black box.
+      const text = ev.payload?.message ?? ""
+      if (!text) return null
+      return ev.payload?.level === "error"
+        ? { kind: "error", text }
+        : { kind: "system", text: `· ${text}` }
+    }
+
+    case "status.update": {
+      const kind = ev.payload?.kind
+      const text = ev.payload?.text ?? ""
+      side.onStatus?.(text)
+      // Generic "status" is cosmetic; lifecycle/error/warn carry real
+      // signal (retries, fallbacks, auth failures) and must persist.
+      if (!kind || kind === "status") return null
+      return { kind: "system", text }
+    }
+  }
+  return null
+}

package/src/app/launch.ts

@@ -0,0 +1,41 @@
+// Launch intent parsed from argv before the renderer starts.
+// Bare `herm` → fresh session (splash shows continue-prompt).
+// `-c` / `--continue` / `--resume [id]` → resume, no splash.
+
+import pkg from "../../package.json" with { type: "json" }
+
+export const VERSION = pkg.version
+
+export type Launch =
+  | { mode: "new"; splash?: boolean }
+  | { mode: "resume"; sid?: string }
+
+/** Parse process argv (everything after the script path). No deps. */
+export function parseLaunch(argv: readonly string[]): Launch {
+  let splash = true
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (a === "--no-splash") { splash = false; continue }
+    if (a === "-c" || a === "--continue") return { mode: "resume" }
+    if (a === "--resume") {
+      const next = argv[i + 1]
+      // Treat a following non-flag token as the session id.
+      return next && !next.startsWith("-")
+        ? { mode: "resume", sid: next }
+        : { mode: "resume" }
+    }
+  }
+  return { mode: "new", splash }
+}
+
+export const HELP = `\
+herm — OpenTUI client for hermes-agent
+
+Usage:
+  herm                    start a fresh session
+  herm -c, --continue     resume the last real TUI session
+  herm --resume [id]      resume last (or the given) session
+  herm --no-splash        skip the launch splash
+  herm -v, --version      print version
+  herm -h, --help         show this help
+`

package/src/app/skin.tsx

@@ -0,0 +1,31 @@
+// Active Hermes skin — branding strings surfaced to UI.
+// The gateway emits skin.changed with the full skin payload;
+// app.tsx reduces it into this context. Consumers read agentName
+// (message headers, announcements) and the raw branding map for
+// future needs (prompt_symbol, welcome, etc.).
+
+import { createContext, useContext, memo, type ReactNode } from "react"
+import type { GatewaySkin } from "../utils/gateway-types"
+
+export type SkinState = {
+  skin?: GatewaySkin
+  /** Preferred display label for the assistant in chat. */
+  agentName: string
+}
+
+const DEFAULT: SkinState = { agentName: "Hermes" }
+
+const Ctx = createContext<SkinState>(DEFAULT)
+
+export function deriveSkin(skin?: GatewaySkin | null): SkinState {
+  const name = skin?.branding?.agent_name?.trim()
+  return { skin: skin ?? undefined, agentName: name || "Hermes" }
+}
+
+export const SkinProvider = memo(({ value, children }: { value: SkinState; children: ReactNode }) => (
+  <Ctx.Provider value={value}>{children}</Ctx.Provider>
+))
+
+export function useSkin(): SkinState {
+  return useContext(Ctx)
+}

package/src/app/spawnHistory.ts

@@ -0,0 +1,75 @@
+// Accumulates subagent.* events across a turn so the completed spawn
+// tree can be persisted via `spawn_tree.save` and later browsed with
+// `spawn_tree.list`/`load`. The accumulator is module-level (one turn
+// runs at a time per session); `flush()` is called from the app-level
+// onTurnComplete side-effect.
+
+import type { Gateway } from "./gateway"
+import type { SubagentPayload, SpawnSubagent } from "../utils/gateway-types"
+
+type Event = "start" | "thinking" | "tool" | "progress" | "complete"
+
+const TRAIL_MAX = 20
+const acc = new Map<string, SpawnSubagent>()
+
+export function record(ev: Event, p: SubagentPayload): void {
+  const id = p.subagent_id
+  if (!id) return
+  const now = Date.now() / 1000
+
+  if (ev === "start") {
+    acc.set(id, {
+      subagent_id: id,
+      parent_id: p.parent_id ?? null,
+      depth: p.depth ?? 0,
+      goal: p.goal,
+      model: p.model,
+      started_at: now,
+      tool_count: 0,
+      status: "running",
+      trail: [],
+    })
+    return
+  }
+
+  const r = acc.get(id)
+  if (!r) return
+
+  if (ev === "tool" && p.tool_name) {
+    r.tool_count++
+    r.trail = [...(r.trail ?? []), { name: p.tool_name, preview: p.tool_preview }].slice(-TRAIL_MAX)
+    return
+  }
+
+  if (ev === "complete") {
+    r.status = p.status ?? "completed"
+    r.finished_at = now
+    r.input_tokens = p.input_tokens
+    r.output_tokens = p.output_tokens
+    r.cost_usd = p.cost_usd
+  }
+}
+
+/** Live read for the Agents-tab detail panel (running children only). */
+export function trail(id: string): ReadonlyArray<{ name: string; preview?: string }> {
+  return acc.get(id)?.trail ?? []
+}
+
+/** Persist the turn's tree (best-effort) and clear the accumulator. */
+export function flush(gw: Gateway, sessionId: string): void {
+  if (acc.size === 0) return
+  const subagents = [...acc.values()]
+  acc.clear()
+
+  const roots = subagents.filter(s => s.parent_id == null)
+  const label = (roots.slice(0, 2).map(s => s.goal).join(" · ") || `${subagents.length} subagents`).slice(0, 120)
+  const started = Math.min(...subagents.map(s => s.started_at))
+
+  gw.request("spawn_tree.save", {
+    session_id: sessionId,
+    label,
+    started_at: started,
+    finished_at: Date.now() / 1000,
+    subagents,
+  }).catch(() => {})
+}

package/src/app/tabs.ts

@@ -0,0 +1,23 @@
+export const TABS = [
+  { name: "Chat",      description: "Main chat interface" },
+  { name: "Context",   description: "Context and session info" },
+  { name: "Sessions",  description: "Session history" },
+  { name: "Agents",    description: "Profiles and running subagents" },
+  { name: "Analytics", description: "Token usage and costs" },
+  { name: "Skills",    description: "Installed skills browser" },
+  { name: "Cron",      description: "Scheduled job manager" },
+  { name: "Toolsets",  description: "Available toolsets manager" },
+  { name: "Config",    description: "Configuration editor" },
+  { name: "Env",       description: "API keys & env variables" },
+  { name: "Memory",    description: "Agent memory browser" },
+  { name: "Kanban",    description: "Multi-agent task board" },
+] as const
+
+export const TAB_MAX = TABS.length - 1
+export const CHAT_TAB = 0
+
+/** Slash-command names that jump to a tab (F5.3). */
+export const TAB_SLASH: Record<string, number> = Object.fromEntries(
+  TABS.map((t, i) => [t.name.toLowerCase(), i]),
+)
+TAB_SLASH.insights = TAB_SLASH.analytics