feat: polish pass + @-reference file attachments

Make bodek feel premium and fluent, and add file/session attachments
by reusing odek serve's resource index — no new agent logic.

Fluency & polish:
- smooth braille spinner; live elapsed timer and cycling status verbs
  while the agent reasons
- per-tool glyphs in the activity feed (shell, read, search, browser…)
- gradient hairline under the header (cached per width)
- smart autoscroll: follows the stream while busy, never yanks you when
  scrolled up reading history; scroll-position indicator in the footer

File attachments (@-references):
- internal/client: Resources() queries odek's /api/resources endpoint
- internal/tui: live @-completion popup (↑/↓ select, ⏎/⇥ insert, esc
  cancel) for files and sessions; dynamic relayout reserves its space
- references resolve server-side via odek's resource registry, going
  through the same untrusted-content boundary as any external input

Tests: resource-event decode, ref parsing (activeRef/refStart), tool
glyphs, and a no-TTY smoke test driving a full streaming turn plus the
approval and autocomplete panels at full and narrow widths.

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

Author: jkyberneees

README.md

@@ -77,12 +77,32 @@ by `odek serve` from its usual chain — `~/.odek/config.json` → `./odek.json`
 | Key | Action |
 |-----|--------|
 | `⏎` | Send the prompt |
+| `@` | Open file/session reference completion (see below) |
 | `^J` | Insert a newline in the input |
 | `^T` | Toggle extended thinking for the next turn |
 | `^L` | Clear the conversation |
 | `PgUp` / `PgDn` / wheel | Scroll the transcript |
 | `^C` | Quit |
 
+### File attachments / `@` references
+
+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.
+
+| Reference | Resolves to |
+|-----------|-------------|
+| `@path/to/file` | The file's contents, inlined into your prompt |
+| `@sess:<id>` | A saved session transcript |
+
+```
+> summarize @internal/client/client.go and compare it with @sess:20260618-ab12
+```
+
+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.
+
 When the agent requests approval for a dangerous operation, answer inline:
 
 | Key | Action |
@@ -96,12 +116,17 @@ When the agent requests approval for a dangerous operation, answer inline:
 ## What you see
 
 - **Streaming answers** rendered as Markdown ([glamour](https://github.com/charmbracelet/glamour)).
-- **Tool activity** — every `tool_call`/`tool_result` shown live with a spinner,
-  argument preview, and a one-line result.
+- **Tool activity** — every `tool_call`/`tool_result` shown live with a glyph
+  per tool, a spinner, an argument preview, and a one-line result.
 - **Security approvals** — odek's `danger` engine prompts surface as an inline
   panel; your answer is sent straight back over the socket.
-- **Live reasoning** — the model's pre-tool thinking streams in dimmed text.
+- **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.
 - **Telemetry** — session token totals and last-turn latency in the chrome.
+- **Fluent by default** — gradient wordmark and hairline, smooth braille
+  spinner, smart autoscroll that never yanks you while you read history, and a
+  scroll-position indicator.
 - **Engine notices** — skill loads, memory merges, and agent signals appear as
   quiet status lines.
 

internal/client/client.go

@@ -10,6 +10,9 @@ package client
 import (
 	"encoding/json"
 	"fmt"
+	"net/http"
+	"net/url"
+	"time"
 
 	ws "golang.org/x/net/websocket"
 )
@@ -64,16 +67,27 @@ type Event struct {
 // socket closes, so the TUI can react instead of hanging.
 const EventDisconnected = "_disconnected"
 
+// Resource is a single @-reference completion candidate from /api/resources.
+type Resource struct {
+	ID     string `json:"id"`     // full reference, e.g. "@src/main.go"
+	Type   string `json:"type"`   // "file" | "session" | "skill"
+	Label  string `json:"label"`  // display label
+	Detail string `json:"detail"` // one-line description
+}
+
 // Client is a connected odek serve session.
 type Client struct {
-	conn   *ws.Conn
-	Events chan Event
+	conn    *ws.Conn
+	baseURL string
+	http    *http.Client
+	Events  chan Event
 }
 
 // Dial connects to an odek serve WebSocket. wsURL is the ws:// endpoint,
-// origin is an http://localhost-based origin accepted by the server, and token
-// is the per-instance CSRF token (obtained from a GET / Set-Cookie header).
-func Dial(wsURL, origin, token string) (*Client, error) {
+// origin is an http://localhost-based origin accepted by the server, baseURL is
+// the http:// root (used for the resource-search API), and token is the
+// per-instance CSRF token (obtained from a GET / Set-Cookie header).
+func Dial(wsURL, origin, baseURL, token string) (*Client, error) {
 	cfg, err := ws.NewConfig(wsURL, origin)
 	if err != nil {
 		return nil, fmt.Errorf("ws config: %w", err)
@@ -85,11 +99,35 @@ func Dial(wsURL, origin, token string) (*Client, error) {
 		return nil, fmt.Errorf("ws dial: %w", err)
 	}
 
-	c := &Client{conn: conn, Events: make(chan Event, 256)}
+	c := &Client{
+		conn:    conn,
+		baseURL: baseURL,
+		http:    &http.Client{Timeout: 3 * time.Second},
+		Events:  make(chan Event, 256),
+	}
 	go c.readLoop()
 	return c, nil
 }
 
+// Resources queries the server's @-reference completion endpoint.
+func (c *Client) Resources(query string, limit int) ([]Resource, error) {
+	u := fmt.Sprintf("%s/api/resources?q=%s&limit=%d",
+		c.baseURL, url.QueryEscape(query), limit)
+	resp, err := c.http.Get(u)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("resources: status %s", resp.Status)
+	}
+	var out []Resource
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // readLoop decodes frames into Events until the socket closes.
 func (c *Client) readLoop() {
 	defer close(c.Events)

internal/tui/banner.go

@@ -35,6 +35,7 @@ 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"},
 		{"⏎ send", "·  ^J newline  ·  ^T toggle thinking"},
 		{"^L clear", "·  PgUp/PgDn scroll  ·  ^C quit"},
 		{"approvals", "answer with [a]pprove [d]eny [t]rust"},

internal/tui/helpers_test.go

@@ -48,3 +48,44 @@ func TestCollapse(t *testing.T) {
 		t.Errorf("collapse: got %q", got)
 	}
 }
+
+func TestActiveRef(t *testing.T) {
+	cases := []struct {
+		in    string
+		want  string
+		match bool
+	}{
+		{"explain @main", "main", true},
+		{"@", "", true},
+		{"look at @src/app.go", "src/app.go", true},
+		{"no ref here", "", false},
+		{"email a@b.com", "", false},  // '@' not at a token boundary
+		{"@sess:abc done", "", false}, // ref already terminated by space
+	}
+	for _, c := range cases {
+		got, ok := activeRef(c.in)
+		if ok != c.match || (ok && got != c.want) {
+			t.Errorf("activeRef(%q) = (%q,%v), want (%q,%v)", c.in, got, ok, c.want, c.match)
+		}
+	}
+}
+
+func TestRefStart(t *testing.T) {
+	in := "please read @internal/x"
+	idx, ok := refStart(in)
+	if !ok || in[idx] != '@' {
+		t.Fatalf("refStart(%q) = %d,%v (char %q)", in, idx, ok, in[idx])
+	}
+	if in[:idx] != "please read " {
+		t.Errorf("prefix = %q", in[:idx])
+	}
+}
+
+func TestToolGlyph(t *testing.T) {
+	if toolGlyph("shell") == toolGlyph("read_file") {
+		t.Error("expected distinct glyphs for shell and read_file")
+	}
+	if toolGlyph("totally_unknown_tool") != "✦" {
+		t.Errorf("unknown tool glyph = %q", toolGlyph("totally_unknown_tool"))
+	}
+}

internal/tui/icons.go

@@ -0,0 +1,44 @@
+package tui
+
+import "strings"
+
+// toolGlyph returns a tasteful monochrome glyph for a tool, so the activity
+// feed reads at a glance. Matching is by substring to cover odek's native
+// tools, MCP tools (server__tool), and sub-agent variants.
+func toolGlyph(name string) string {
+	n := strings.ToLower(name)
+	switch {
+	case strings.Contains(n, "shell"), strings.Contains(n, "bash"), strings.Contains(n, "exec"):
+		return "❯"
+	case strings.Contains(n, "write"), strings.Contains(n, "patch"), strings.Contains(n, "edit"):
+		return "✎"
+	case strings.Contains(n, "read"):
+		return "◰"
+	case strings.Contains(n, "list"), strings.Contains(n, "dir"), strings.Contains(n, "ls"):
+		return "▤"
+	case strings.Contains(n, "search"), strings.Contains(n, "grep"), strings.Contains(n, "find"):
+		return "⌕"
+	case strings.Contains(n, "browser"), strings.Contains(n, "http"), strings.Contains(n, "fetch"), strings.Contains(n, "web"):
+		return "◉"
+	case strings.Contains(n, "delegate"), strings.Contains(n, "subagent"), strings.Contains(n, "task"):
+		return "⑂"
+	case strings.Contains(n, "memory"), strings.Contains(n, "recall"):
+		return "❖"
+	case strings.Contains(n, "vision"), strings.Contains(n, "image"), strings.Contains(n, "transcribe"):
+		return "◎"
+	default:
+		return "✦"
+	}
+}
+
+// resourceGlyph returns a glyph for an @-reference result type.
+func resourceGlyph(typ string) string {
+	switch typ {
+	case "session":
+		return "⟳"
+	case "skill":
+		return "✦"
+	default: // file
+		return "≡"
+	}
+}