feat(tui): /command palette; scope @ to file attachments

Add standard slash-command support and a completion palette that mirrors
the @ popup:

- type "/" for a command palette (↑/↓ select, ⇥ complete, ⏎ run, esc):
  /help, /clear, /sessions, /model [name], /thinking [on|off], /cancel, /quit
- a fully-typed "/cmd args" + ⏎ runs directly; commands work mid-turn
  (e.g. /cancel) and never get sent to the agent
- /help renders a command + keybinding card

Scope @ to attachments only: the completion now suggests files (sessions
are reached via /sessions or ^R), with a relabeled popup and a command
glyph. README, welcome tips, and key-binding docs updated.

Fully covered by tests (commands.go 100%); suite + lint green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012rWqu7pktbd2ejfNw3a7Vf

Author: jkyberneees

README.md

@@ -81,8 +81,9 @@ by `odek serve` from its usual chain — `~/.odek/config.json` → `./odek.json`
 
 | Key | Action |
 |-----|--------|
-| `⏎` | Send the prompt |
-| `@` | Open file/session reference completion (see below) |
+| `⏎` | Send the prompt (or run a `/command`) |
+| `/` | Open the command palette (see below) |
+| `@` | Attach a file (see below) |
 | `^R` | Browse & resume saved sessions |
 | `^O` | Switch the model |
 | `^T` | Toggle extended thinking for the next turn |
@@ -92,24 +93,35 @@ by `odek serve` from its usual chain — `~/.odek/config.json` → `./odek.json`
 | `PgUp` / `PgDn` / wheel | Scroll the transcript |
 | `^C` | Quit |
 
-### File attachments / `@` references
+### Commands (`/`)
 
-Type `@` in the input to attach context. bodek queries odek's resource index
-live and shows a completion popup; `↑`/`↓` to choose, `⏎` or `⇥` to insert,
-`esc` to dismiss.
+Type `/` at the start of the input for a command palette. `↑`/`↓` to choose,
+`⇥` to complete, `⏎` to run, `esc` to dismiss. You can also just type the full
+command and press `⏎`.
 
-| Reference | Resolves to |
-|-----------|-------------|
-| `@path/to/file` | The file's contents, inlined into your prompt |
-| `@sess:<id>` | A saved session transcript |
+| Command | Action |
+|---------|--------|
+| `/help` | List commands and key bindings |
+| `/clear` | Clear the conversation |
+| `/sessions` | Browse & resume saved sessions |
+| `/model [name]` | Switch model (opens a picker with no argument) |
+| `/thinking [on\|off]` | Toggle extended thinking |
+| `/cancel` | Cancel the running turn |
+| `/quit` | Exit bodek |
+
+### File attachments (`@`)
+
+Type `@` to attach a file. bodek searches the working tree and shows a
+completion popup; `↑`/`↓` to choose, `⏎` or `⇥` to insert, `esc` to dismiss.
 
 ```
-> summarize @internal/client/client.go and compare it with @sess:20260618-ab12
+> summarize @internal/client/client.go and explain the protocol
 ```
 
-odek resolves and inlines the referenced content **server-side** (wrapped in
-its untrusted-content boundary), so attachments go through the same security
-model as any other external input — bodek doesn't special-case them.
+odek resolves and inlines the file content **server-side** (wrapped in its
+untrusted-content boundary), so attachments go through the same security model
+as any other external input — bodek doesn't special-case them. (Saved sessions
+are resumed via `/sessions` or `^R`, not `@`.)
 
 When the agent requests approval for a dangerous operation, answer inline:
 
@@ -130,7 +142,7 @@ When the agent requests approval for a dangerous operation, answer inline:
   panel; your answer is sent straight back over the socket.
 - **Live reasoning** — the model's pre-tool thinking streams in dimmed text,
   with a running elapsed timer and cycling status while it works.
-- **`@` autocomplete** — a live, navigable popup of files and sessions.
+- **Command palette (`/`)** and **file attachments (`@`)** — live, navigable popups.
 - **Context-aware progress** — while the agent works, the status badge shows
   what it's actually doing (`🧪 running tests`, `📖 reading client.go`,
   `🚀 pushing`) with a live elapsed timer.

internal/tui/banner.go

@@ -35,7 +35,8 @@ func welcome(th theme, width int) string {
 
 	tips := [][2]string{
 		{"type a task", "and press enter to run the agent"},
-		{"@ to attach", "reference files & sessions, e.g. @main.go"},
+		{"/ commands", "type / for commands, e.g. /help /sessions /model"},
+		{"@ to attach", "attach files, e.g. @main.go"},
 		{"⏎ send", "·  ^J newline  ·  ^T toggle thinking"},
 		{"^L clear", "·  PgUp/PgDn scroll  ·  ^C quit"},
 		{"approvals", "answer with [a]pprove [d]eny [t]rust"},

internal/tui/commands.go

@@ -0,0 +1,156 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/BackendStack21/bodek/internal/client"
+)
+
+// command is a slash command typed in the input as "/name [args]".
+type command struct {
+	name string
+	desc string
+	run  func(m *Model, args string) tea.Cmd
+}
+
+// slashCommands is the registry. Keeping it a function keeps the closures
+// simple and avoids package-init ordering concerns.
+func slashCommands() []command {
+	return []command{
+		{"help", "show available commands", func(m *Model, _ string) tea.Cmd {
+			m.showHelp()
+			return nil
+		}},
+		{"clear", "clear the conversation", func(m *Model, _ string) tea.Cmd {
+			m.msgs = nil
+			m.curIdx = -1
+			m.refresh()
+			return nil
+		}},
+		{"sessions", "browse & resume saved sessions", func(m *Model, _ string) tea.Cmd {
+			return m.openSessions()
+		}},
+		{"model", "switch model — /model [name]", func(m *Model, args string) tea.Cmd {
+			if args != "" {
+				m.pendModel = args
+				m.model = args
+				m.addNote("model set to " + args + " (applies next turn)")
+				m.refresh()
+				return nil
+			}
+			return m.openModels()
+		}},
+		{"thinking", "extended thinking — /thinking [on|off]", func(m *Model, args string) tea.Cmd {
+			switch strings.ToLower(args) {
+			case "on", "enabled", "true":
+				m.thinkOn = true
+			case "off", "disabled", "false":
+				m.thinkOn = false
+			default:
+				m.thinkOn = !m.thinkOn
+			}
+			state := "off"
+			if m.thinkOn {
+				state = "on"
+			}
+			m.addNote("thinking " + state)
+			m.refresh()
+			return nil
+		}},
+		{"cancel", "cancel the running turn", func(m *Model, _ string) tea.Cmd {
+			return m.cancelRun()
+		}},
+		{"quit", "exit bodek", func(m *Model, _ string) tea.Cmd {
+			m.quitting = true
+			return tea.Quit
+		}},
+	}
+}
+
+// commandPrefix reports the command token when the input is a line-initial
+// slash command still being typed (a leading "/" with no whitespace yet).
+func commandPrefix(s string) (string, bool) {
+	if !strings.HasPrefix(s, "/") {
+		return "", false
+	}
+	body := s[1:]
+	if strings.ContainsAny(body, " \t\n") {
+		return "", false
+	}
+	return body, true
+}
+
+// runCommandLine parses and dispatches a full "/name args" line.
+func (m *Model) runCommandLine(text string) tea.Cmd {
+	body := strings.TrimPrefix(text, "/")
+	name, args := body, ""
+	if i := strings.IndexAny(body, " \t"); i >= 0 {
+		name, args = body[:i], strings.TrimSpace(body[i+1:])
+	}
+	return m.runCommand(name, args)
+}
+
+// runCommand finds and executes a command by name, resetting the input.
+func (m *Model) runCommand(name, args string) tea.Cmd {
+	m.ta.Reset()
+	m.closeAC()
+	for _, c := range slashCommands() {
+		if c.name == name {
+			return c.run(m, args)
+		}
+	}
+	m.addNote("unknown command: /" + name + " — try /help")
+	m.refresh()
+	return nil
+}
+
+// runSelectedCommand executes the command highlighted in the popup.
+func (m *Model) runSelectedCommand() tea.Cmd {
+	if len(m.ac.items) == 0 {
+		m.closeAC()
+		return nil
+	}
+	name := strings.TrimPrefix(m.ac.items[m.ac.sel].ID, "/")
+	return m.runCommand(name, "")
+}
+
+// openCmdAC populates the popup with commands matching the typed prefix.
+func (m *Model) openCmdAC(query string) {
+	var items []client.Resource
+	for _, c := range slashCommands() {
+		if strings.HasPrefix(c.name, query) {
+			items = append(items, client.Resource{
+				ID: "/" + c.name, Type: "command", Label: "/" + c.name, Detail: c.desc,
+			})
+		}
+	}
+	m.ac.open = true
+	m.ac.loading = false
+	m.ac.mode = acCmd
+	m.ac.query = query
+	m.ac.items = items
+	m.ac.seq++ // invalidate any in-flight @-search result
+	if m.ac.sel >= len(items) {
+		m.ac.sel = 0
+	}
+	m.relayout()
+	m.refresh()
+}
+
+// showHelp appends a rendered help card listing commands and key bindings.
+func (m *Model) showHelp() {
+	var b strings.Builder
+	b.WriteString("### Commands\n\n")
+	for _, c := range slashCommands() {
+		b.WriteString(fmt.Sprintf("- `/%s` — %s\n", c.name, c.desc))
+	}
+	b.WriteString("\n### Keys\n\n")
+	b.WriteString("`@` attach files/sessions · `^R` sessions · `^O` model · " +
+		"`^T` thinking · `^J` newline · `Esc` cancel · `^L` clear · `^C` quit\n")
+	content := b.String()
+	m.msgs = append(m.msgs, message{role: roleAsst, content: content, rendered: m.render(content)})
+	m.refresh()
+}