Merge pull request 'feat(tui): add bubbletea terminal UI' (#30) from feat/tui into main

Reviewed-on: #30

.air.toml

@@ -0,0 +1,18 @@
+root = "."
+tmp_dir = "tmp"
+
+[build]
+  bin = "./tmp/nib"
+  cmd = "go build -o ./tmp/nib ."
+  args_bin = ["serve"]
+  delay = 500
+  exclude_dir = ["tmp", "testdata", "docs"]
+  exclude_regex = ["_test\\.go$"]
+  include_ext = ["go", "html", "css", "js", "svg"]
+  kill_delay = 500
+
+[log]
+  time = false
+
+[misc]
+  clean_on_exit = true

.gitea/issue_template/bug.yaml

@@ -0,0 +1,29 @@
+name: Bug
+about: Something broken
+body:
+  - type: input
+    id: what
+    attributes:
+      label: What happened
+      placeholder: "stream entries disappear at mobile breakpoint"
+    validations:
+      required: true
+  - type: input
+    id: expected
+    attributes:
+      label: Expected
+      placeholder: "entries stay visible when viewport narrows"
+  - type: dropdown
+    id: area
+    attributes:
+      label: Area
+      options:
+        - ui
+        - api
+        - data
+        - other
+  - type: input
+    id: repro
+    attributes:
+      label: Repro steps (if not obvious)
+      placeholder: "zoom to 67%, press z twice"

.gitea/issue_template/feature.yaml

@@ -0,0 +1,29 @@
+name: Feature
+about: New capability or enhancement
+body:
+  - type: input
+    id: what
+    attributes:
+      label: What
+      placeholder: "inline tag editing in stream view"
+    validations:
+      required: true
+  - type: input
+    id: why
+    attributes:
+      label: Why
+      placeholder: "avoid opening peek just to add a tag"
+  - type: dropdown
+    id: area
+    attributes:
+      label: Area
+      options:
+        - ui
+        - api
+        - data
+        - other
+  - type: input
+    id: notes
+    attributes:
+      label: Notes
+      placeholder: "see mockup in docs/.local/"

.gitignore

@@ -1,5 +1,7 @@
 # Binary
 nib
+tmp/
+certs/
 
 # Database
 *.db
@@ -22,9 +24,6 @@ nib
 .DS_Store
 Thumbs.db
 
-# Spec (not shipped)
-nib-unified-spec.md
-
 # Shell/profile dotfiles (host artifacts)
 .bash_profile
 .bashrc
@@ -35,3 +34,6 @@ nib-unified-spec.md
 .gitmodules
 .ripgreprc
 .mcp.json
+
+# Local Documents
+.local/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tyler Koenig
+
+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.

Makefile

@@ -0,0 +1,71 @@
+BINARY  := nib
+MODULE  := github.com/lerko/nib
+GOFLAGS := -trimpath
+
+.PHONY: build dev tui watch test lint fmt vet clean run cert help
+
+## —— Build ——————————————————————————————————
+
+build: ## Build production binary
+	go build $(GOFLAGS) -o $(BINARY) .
+
+dev: ## Build and run with default serve
+	go run . serve
+
+tui: ## Launch the terminal UI
+	go run . tui
+
+watch: ## Live-reload dev server (requires air)
+	air
+
+## —— Quality ————————————————————————————————
+
+test: ## Run all tests
+	go test ./...
+
+test-v: ## Run all tests (verbose)
+	go test -v ./...
+
+test-cover: ## Run tests with coverage report
+	go test -coverprofile=coverage.out ./...
+	go tool cover -func=coverage.out
+	@rm -f coverage.out
+
+lint: vet fmt-check ## Run all linters
+
+vet: ## Run go vet
+	go vet ./...
+
+fmt: ## Format all Go files
+	gofmt -w .
+
+fmt-check: ## Check formatting (fails if unformatted)
+	@test -z "$$(gofmt -l .)" || (echo "unformatted files:" && gofmt -l . && exit 1)
+
+## —— Utility ————————————————————————————————
+
+cert: ## Generate self-signed dev TLS cert (certs/)
+	@mkdir -p certs
+	openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 \
+		-nodes -keyout certs/dev.key -out certs/dev.crt -days 365 \
+		-subj "/CN=localhost"
+	@echo "  certs/dev.crt and certs/dev.key ready"
+	@echo "  usage: make run ARGS=\"serve --tls-cert certs/dev.crt --tls-key certs/dev.key\""
+
+clean: ## Remove build artifacts
+	rm -f $(BINARY) coverage.out
+
+run: build ## Build then run with args (usage: make run ARGS="serve")
+	./$(BINARY) $(ARGS)
+
+tidy: ## Tidy and verify module dependencies
+	go mod tidy
+	go mod verify
+
+## —— Help ———————————————————————————————————
+
+help: ## Show this help
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \
+		awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-14s\033[0m %s\n", $$1, $$2}'
+
+.DEFAULT_GOAL := help

README.md

@@ -0,0 +1,172 @@
+# nib
+
+Capture-first note system. Catch thoughts, todos, and events before they slip — from terminal or browser. Everything lives in a single SQLite file.
+
+nib uses a tiny grammar to extract structure from plain text. You type naturally, and nib figures out what it is: a thought, a todo with a due date, an event, a titled reference. Tags, descriptions, and time anchors are pulled out automatically. The body stays as markdown.
+
+When something proves useful, promote it to a card (snippet, template, checklist, decision, link) for quick reuse. Cards track usage and float to the top.
+
+## Install
+
+Requires Go 1.24+.
+
+```
+go build -o nib .
+```
+
+Data lives at `~/.nib/nib.db` by default. Override with `NIB_DB=/path/to/file.db`.
+
+## Quick start
+
+```bash
+# capture a thought
+nib "proxy_pass needs a trailing slash"
+
+# todo
+nib "- buy mass gainer @tomorrow #errands"
+
+# titled entry with description
+nib "|nginx proxy trick // always forget this #ops"
+
+# todo with a title
+nib "- |deploy staging // rebuild docker image #ops"
+
+# list recent entries
+nib ls
+
+# list by tag
+nib ls --tag ops
+
+# list a specific month
+nib ls --month 2026-05
+
+# terminal UI
+nib tui
+
+# start the web UI
+nib serve
+```
+
+Open `http://localhost:4444` for the browser interface.
+
+## Grammar
+
+The full grammar fits on an index card. Here's what matters:
+
+### Kind prefixes
+
+The first character decides what kind of entry you're creating.
+
+| Input | Kind | Example |
+|-------|------|---------|
+| bare text | thought | `just an idea` |
+| `- text` | todo | `- buy milk @tomorrow` |
+| `@time text` | event | `@friday 2pm lunch with alex` |
+| `!time text` | reminder | `!3pm call dentist` |
+
+The dash needs a space after it. `-deploy` is a thought, `- deploy` is a todo.
+
+### Titles and descriptions
+
+Give an entry a name with `|` at the start. Add a description with `//`.
+
+```
+|nginx proxy trick
+proxy_pass http://backend/;
+
+|deploy checklist // for staging #ops
+1. docker build
+2. docker push
+3. ssh prod && restart
+
+// quick reference for proxy config
+the actual body text goes here
+
+body text // this part becomes the description
+```
+
+Title shows as the scan label in list view. Description appears in the detail pane. Both are optional — most captures won't need them.
+
+### Tags and flags
+
+Tags and flags work anywhere in the input. They're extracted and removed from the body.
+
+```
+deploy nginx #ops #infra        → tags: ops, infra
+important thing !pin            → pinned to top
+use ##channel in slack          → literal #channel in body (escaped)
+```
+
+### Cards
+
+Promote a fluid entry to a card for reuse:
+
+```bash
+nib promote <id> snippet    # code trick, copy-to-clipboard
+nib promote <id> template   # has ${slots} to fill
+nib promote <id> checklist  # step-through items
+nib promote <id> decision   # chose/why/rejected
+nib promote <id> link       # URL with an open button
+```
+
+Or use `^type` inline: `nib "proxy trick #nginx ^card"`
+
+## CLI commands
+
+| Command | What it does |
+|---------|-------------|
+| `nib <input>` | Capture (shorthand for `nib add`) |
+| `nib ls` | List entries — filter with `--tag`, `--date`, `--month`, `--from`/`--to` |
+| `nib cards` | List cards sorted by usage |
+| `nib edit <id>` | Open in `$EDITOR` |
+| `nib copy <id>` | Copy body to clipboard |
+| `nib promote <id> [type]` | Promote to card |
+| `nib demote <id>` | Strip card, back to fluid |
+| `nib absorb <target> <source>` | Merge source into target |
+| `nib delete <id>` | Soft delete (repeat to hard delete) |
+| `nib serve` | Start web UI on `:4444` (or `--port`) |
+| `nib tui` | Launch the terminal UI |
+
+IDs are prefix-matchable. If `01KRQ4` is unique, that's enough.
+
+## Terminal UI
+
+`nib tui` launches a keyboard-driven interface in your terminal.
+
+- **Stream view** — entries grouped by date with compact gutter headers
+- **Cards view** — promoted cards filtered by intent (grab/read/fill), sorted by usage
+- **Split-pane detail** — wide terminals (100+ cols) show list and detail side-by-side
+- **Capture drawer** — inline add with live preview of parsed entity
+- **Search** — type `?query #tag` in the capture bar to filter
+
+Navigation: `j`/`k` move, `enter` opens detail, `h`/`l` switch panes, `a` to add, `?` for full keybindings.
+
+## Web UI
+
+`nib serve` starts a local web interface with:
+
+- **Capture bar** — same grammar as the CLI
+- **Stream view** — entries grouped by date, newest first
+- **Cards view** — promoted cards sorted by use count
+- **Tag rail** — filter by tag
+- **Month navigator** — browse by date range
+- **Detail pane** — full entry view, double-click to edit
+- **Keyboard shortcuts** — `j`/`k` navigate, `n` to capture, `p` to promote, `e` to edit, `dd` to delete
+
+Dark and light themes. Toggle with the button in the header.
+
+## Data
+
+Everything is one SQLite file. Back it up, sync it, move it between machines — it's just a file. WAL mode is on for concurrent reads.
+
+```bash
+# back up
+cp ~/.nib/nib.db ~/.nib/nib.db.bak
+
+# use a different database
+NIB_DB=/path/to/other.db nib ls
+```
+
+## License
+
+MIT

cmd/add.go

@@ -33,8 +33,11 @@ func runAdd(_ *cobra.Command, args []string) error {
 
 	e := &db.Entity{
 		Body:        parsed.Body,
+		Title:       parsed.Title,
+		Description: parsed.Description,
 		Glyph:       db.Glyph(parsed.Glyph),
 		Tags:        parsed.Tags,
+		Pinned:      parsed.Pin,
 	}
 	if parsed.TimeAnchor != nil {
 		e.TimeAnchor = parsed.TimeAnchor
@@ -53,7 +56,11 @@ func runAdd(_ *cobra.Command, args []string) error {
 
 	var parts []string
 	parts = append(parts, glyph)
+	if e.Title != nil {
+		parts = append(parts, "  "+*e.Title)
+	} else {
 		parts = append(parts, "  "+e.Body)
+	}
 	if e.TimeAnchor != nil {
 		parts = append(parts, "  @"+*e.TimeAnchor)
 	}

cmd/cards.go

@@ -63,8 +63,13 @@ func runCards(_ *cobra.Command, _ []string) error {
 			tagStr += " #" + tag
 		}
 
+		label := e.Body
+		if e.Title != nil {
+			label = *e.Title
+		}
+
 		fmt.Printf("%s  %-40s %-16s %3d×  %s\n",
-			glyph, e.Body,
+			glyph, label,
 			strings.TrimSpace(tagStr),
 			e.UseCount, shortID)
 	}

cmd/demo.go

@@ -0,0 +1,139 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/lerko/nib/internal/db"
+	"github.com/spf13/cobra"
+)
+
+var demoCmd = &cobra.Command{
+	Use:   "demo",
+	Short: "start server with pre-populated demo data",
+	RunE:  runDemo,
+}
+
+func init() {
+	rootCmd.AddCommand(demoCmd)
+}
+
+type demoEntity struct {
+	Body        string   `json:"body"`
+	Glyph       string   `json:"glyph"`
+	Title       *string  `json:"title,omitempty"`
+	Description *string  `json:"description,omitempty"`
+	TimeAnchor  *string  `json:"time_anchor,omitempty"`
+	Pinned      bool     `json:"pinned"`
+	Completed   bool     `json:"completed"`
+	Deleted     bool     `json:"deleted"`
+	CardType    *string  `json:"card_type,omitempty"`
+	CardData    *string  `json:"card_data,omitempty"`
+	Tags        []string `json:"tags"`
+}
+
+func runDemo(_ *cobra.Command, _ []string) error {
+	tmpDir, err := os.MkdirTemp("", "nib-demo-*")
+	if err != nil {
+		return err
+	}
+	dbPath := filepath.Join(tmpDir, "demo.db")
+	fmt.Printf("demo db: %s\n", dbPath)
+
+	store, err := db.Open(dbPath)
+	if err != nil {
+		return err
+	}
+
+	if err := seedDemo(store); err != nil {
+		store.Close()
+		return fmt.Errorf("seed demo data: %w", err)
+	}
+	store.Close()
+
+	os.Setenv("NIB_DB", dbPath)
+	return runServe(nil, nil)
+}
+
+func seedDemo(store *db.Store) error {
+	data, err := findDemoFile()
+	if err != nil {
+		return err
+	}
+
+	var entries []demoEntity
+	if err := json.Unmarshal(data, &entries); err != nil {
+		return fmt.Errorf("parse demo.json: %w", err)
+	}
+
+	now := time.Now().UTC()
+	for i, entry := range entries {
+		e := &db.Entity{
+			Body:  entry.Body,
+			Glyph: db.Glyph(entry.Glyph),
+			Tags:  entry.Tags,
+		}
+
+		if entry.Title != nil {
+			e.Title = entry.Title
+		}
+		if entry.Description != nil {
+			e.Description = entry.Description
+		}
+		if entry.TimeAnchor != nil {
+			e.TimeAnchor = entry.TimeAnchor
+		}
+		if entry.Pinned {
+			e.Pinned = true
+		}
+		if entry.Completed {
+			t := now.Add(-time.Duration(i) * time.Hour)
+			e.CompletedAt = &t
+		}
+
+		if err := store.Create(e); err != nil {
+			return fmt.Errorf("entity %d: %w", i, err)
+		}
+
+		if entry.CardType != nil {
+			ct := db.CardType(*entry.CardType)
+			if err := store.Promote(e.ID, ct, entry.CardData); err != nil {
+				return fmt.Errorf("promote entity %d: %w", i, err)
+			}
+		}
+
+		if entry.Deleted {
+			store.SoftDelete(e.ID)
+		}
+	}
+
+	fmt.Printf("seeded %d entities\n", len(entries))
+	return nil
+}
+
+func findDemoFile() ([]byte, error) {
+	candidates := []string{
+		"testdata/demo.json",
+		filepath.Join(execDir(), "testdata", "demo.json"),
+	}
+
+	for _, path := range candidates {
+		data, err := os.ReadFile(path)
+		if err == nil {
+			return data, nil
+		}
+	}
+
+	return nil, fmt.Errorf("demo.json not found (looked in: %v)", candidates)
+}
+
+func execDir() string {
+	exe, err := os.Executable()
+	if err != nil {
+		return "."
+	}
+	return filepath.Dir(exe)
+}

cmd/ls.go

@@ -142,8 +142,13 @@ func printEntity(e *db.Entity) {
 	glyph := display.DisplayGlyph(e.Glyph, e.CardType)
 	shortID := display.FormatID(e.ID)
 
+	label := e.Body
+	if e.Title != nil {
+		label = *e.Title
+	}
+
 	var line strings.Builder
-	fmt.Fprintf(&line, "%s  %-40s", glyph, e.Body)
+	fmt.Fprintf(&line, "%s  %-40s", glyph, label)
 
 	if e.TimeAnchor != nil {
 		fmt.Fprintf(&line, " @%-5s", *e.TimeAnchor)

cmd/promote.go

@@ -1,11 +1,9 @@
 package cmd
 
 import (
-	"encoding/json"
 	"fmt"
-	"regexp"
-	"strings"
 
+	"github.com/lerko/nib/internal/carddata"
 	"github.com/lerko/nib/internal/db"
 	"github.com/lerko/nib/internal/display"
 	"github.com/spf13/cobra"
@@ -47,9 +45,9 @@ func runPromote(_ *cobra.Command, args []string) error {
 		return err
 	}
 
-	cardData := generateCardData(cardType, e.Body)
+	cd := carddata.GenerateCardData(cardType, e.Body)
 
-	if err := store.Promote(id, cardType, cardData); err != nil {
+	if err := store.Promote(id, cardType, cd); err != nil {
 		if err == db.ErrAlreadyPromoted {
 			return fmt.Errorf("invalid_promote — entity %s is already a %s",
 				display.FormatID(id), *e.CardType)
@@ -60,74 +58,3 @@ func runPromote(_ *cobra.Command, args []string) error {
 	fmt.Printf("promoted %s → %s\n", display.FormatID(id), cardType)
 	return nil
 }
-
-var templateSlotRe = regexp.MustCompile(`\$\{(\w+)\}`)
-
-func generateCardData(ct db.CardType, body string) *string {
-	var data string
-	switch ct {
-	case db.CardTemplate:
-		matches := templateSlotRe.FindAllStringSubmatch(body, -1)
-		type slot struct {
-			Name    string `json:"name"`
-			Default string `json:"default"`
-		}
-		var slots []slot
-		seen := map[string]bool{}
-		for _, m := range matches {
-			name := m[1]
-			if !seen[name] {
-				slots = append(slots, slot{Name: name, Default: ""})
-				seen[name] = true
-			}
-		}
-		if slots == nil {
-			slots = []slot{}
-		}
-		b, _ := json.Marshal(map[string]any{"slots": slots})
-		data = string(b)
-
-	case db.CardChecklist:
-		type step struct {
-			Text string `json:"text"`
-			Done bool   `json:"done"`
-		}
-		var steps []step
-		for _, line := range strings.Split(body, "\n") {
-			line = strings.TrimSpace(line)
-			if strings.HasPrefix(line, "[ ]") || strings.HasPrefix(line, "[x]") {
-				text := strings.TrimSpace(line[3:])
-				done := strings.HasPrefix(line, "[x]")
-				steps = append(steps, step{Text: text, Done: done})
-			}
-		}
-		if steps == nil {
-			steps = []step{{Text: body, Done: false}}
-		}
-		b, _ := json.Marshal(map[string]any{"steps": steps})
-		data = string(b)
-
-	case db.CardDecision:
-		b, _ := json.Marshal(map[string]any{
-			"chose":    "",
-			"why":      "",
-			"rejected": []string{},
-		})
-		data = string(b)
-
-	case db.CardLink:
-		url := ""
-		for _, word := range strings.Fields(body) {
-			if strings.HasPrefix(word, "http://") || strings.HasPrefix(word, "https://") {
-				url = word
-				break
-			}
-		}
-		b, _ := json.Marshal(map[string]any{"url": url})
-		data = string(b)
-
-	default:
-		data = "{}"
-	}
-	return &data
-}

cmd/root.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"fmt"
 	"os"
 	"strings"
 
@@ -26,6 +27,10 @@ func Execute() error {
 		isFlag := strings.HasPrefix(first, "-") && !strings.Contains(first, " ")
 		if first != "help" && first != "completion" &&
 			!isFlag && !isSubcommand(first) {
+			if near := nearSubcommand(first); near != "" {
+				fmt.Fprintf(os.Stderr, "unknown command %q — did you mean %q?\n", first, near)
+				os.Exit(1)
+			}
 			// "--" stops cobra from parsing glyph prefixes like "-" as flags
 			rootCmd.SetArgs(append([]string{"add", "--"}, os.Args[1:]...))
 		}
@@ -47,6 +52,56 @@ func isSubcommand(name string) bool {
 	return false
 }
 
+func nearSubcommand(name string) string {
+	for _, c := range rootCmd.Commands() {
+		if d := editDist(name, c.Name()); d > 0 && d <= 2 {
+			return c.Name()
+		}
+		for _, alias := range c.Aliases {
+			if d := editDist(name, alias); d > 0 && d <= 2 {
+				return alias
+			}
+		}
+	}
+	return ""
+}
+
+func editDist(a, b string) int {
+	la, lb := len(a), len(b)
+	if la == 0 {
+		return lb
+	}
+	if lb == 0 {
+		return la
+	}
+	prev := make([]int, lb+1)
+	for j := range prev {
+		prev[j] = j
+	}
+	for i := 1; i <= la; i++ {
+		curr := make([]int, lb+1)
+		curr[0] = i
+		for j := 1; j <= lb; j++ {
+			cost := 1
+			if a[i-1] == b[j-1] {
+				cost = 0
+			}
+			ins := curr[j-1] + 1
+			del := prev[j] + 1
+			sub := prev[j-1] + cost
+			curr[j] = ins
+			if del < curr[j] {
+				curr[j] = del
+			}
+			if sub < curr[j] {
+				curr[j] = sub
+			}
+		}
+		prev = curr
+	}
+	return prev[lb]
+}
+
 func init() {
 	rootCmd.AddCommand(addCmd)
 	rootCmd.AddCommand(lsCmd)

cmd/serve.go

@@ -19,7 +19,10 @@ var WebFS fs.FS
 
 var (
 	servePort int
+	serveHost string
 	serveDev  bool
+	tlsCert   string
+	tlsKey    string
 )
 
 var serveCmd = &cobra.Command{
@@ -29,12 +32,20 @@ var serveCmd = &cobra.Command{
 }
 
 func init() {
-	serveCmd.Flags().IntVar(&servePort, "port", 0, "port to listen on (default 4444)")
+	serveCmd.Flags().IntVar(&servePort, "port", 0, "port to listen on (default 4444, or 4443 with TLS)")
+	serveCmd.Flags().StringVar(&serveHost, "host", "127.0.0.1", "address to bind to (default localhost only)")
 	serveCmd.Flags().BoolVar(&serveDev, "dev", false, "enable CORS for development")
+	serveCmd.Flags().StringVar(&tlsCert, "tls-cert", "", "path to TLS certificate file")
+	serveCmd.Flags().StringVar(&tlsKey, "tls-key", "", "path to TLS private key file")
 	rootCmd.AddCommand(serveCmd)
 }
 
 func runServe(_ *cobra.Command, _ []string) error {
+	useTLS := tlsCert != "" && tlsKey != ""
+	if (tlsCert != "") != (tlsKey != "") {
+		return fmt.Errorf("both --tls-cert and --tls-key are required for TLS")
+	}
+
 	port := servePort
 	if port == 0 {
 		if envPort := os.Getenv("NIB_PORT"); envPort != "" {
@@ -43,6 +54,8 @@ func runServe(_ *cobra.Command, _ []string) error {
 				return fmt.Errorf("invalid NIB_PORT: %w", err)
 			}
 			port = p
+		} else if useTLS {
+			port = 4443
 		} else {
 			port = 4444
 		}
@@ -59,7 +72,7 @@ func runServe(_ *cobra.Command, _ []string) error {
 		router = api.NewRouter(store, serveDev, WebFS)
 	}
 
-	addr := fmt.Sprintf(":%d", port)
+	addr := fmt.Sprintf("%s:%d", serveHost, port)
 	srv := &http.Server{
 		Addr:    addr,
 		Handler: router,
@@ -69,12 +82,23 @@ func runServe(_ *cobra.Command, _ []string) error {
 	defer stop()
 
 	go func() {
-		fmt.Printf("nib serving on %s\n", addr)
+		if useTLS {
+			fmt.Printf("nib serving on https://%s\n", addr)
+		} else {
+			fmt.Printf("nib serving on http://%s\n", addr)
+		}
 		if serveDev {
 			fmt.Println("  CORS enabled (dev mode)")
 		}
-		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+
-			fmt.Fprintf(os.Stderr, "server error: %v\n", err)
+		var listenErr error
+		if useTLS {
+			listenErr = srv.ListenAndServeTLS(tlsCert, tlsKey)
+		} else {
+			listenErr = srv.ListenAndServe()
+		}
+		if listenErr != nil && listenErr != http.ErrServerClosed {
+			fmt.Fprintf(os.Stderr, "server error: %v\n", listenErr)
 		}
 	}()
 

cmd/tui.go

@@ -0,0 +1,25 @@
+package cmd
+
+import (
+	"github.com/lerko/nib/internal/tui"
+	"github.com/spf13/cobra"
+)
+
+var tuiCmd = &cobra.Command{
+	Use:   "tui",
+	Short: "launch the terminal UI",
+	RunE:  runTUI,
+}
+
+func init() {
+	rootCmd.AddCommand(tuiCmd)
+}
+
+func runTUI(_ *cobra.Command, _ []string) error {
+	store, err := openStore()
+	if err != nil {
+		return err
+	}
+	defer store.Close()
+	return tui.Run(store)
+}

docs/development.md

@@ -0,0 +1,97 @@
+# Development Guide
+
+## Prerequisites
+
+- Go 1.24+
+- [air](https://github.com/air-verse/air) (live-reload, install: `go install github.com/air-verse/air@latest`)
+- OpenSSL (for dev TLS certs)
+
+## Quick Start
+
+```sh
+make cert       # one-time: generate self-signed TLS cert
+make watch      # start dev server with live-reload (HTTP, port 4444)
+```
+
+## Make Targets
+
+### Build
+
+| Target | Description |
+|--------|-------------|
+| `make build` | Compile production binary (`./nib`) |
+| `make dev` | Run dev server from source (HTTP, port 4444) |
+| `make watch` | Live-reload dev server via air — auto-rebuilds on save |
+
+### Quality
+
+| Target | Description |
+|--------|-------------|
+| `make test` | Run all tests |
+| `make test-v` | Run all tests with verbose output |
+| `make test-cover` | Run tests with per-function coverage report |
+| `make lint` | Run vet + format check |
+| `make vet` | Static analysis via `go vet` |
+| `make fmt` | Auto-format all Go files |
+| `make fmt-check` | Check formatting without modifying (CI-friendly) |
+
+### Utility
+
+| Target | Description |
+|--------|-------------|
+| `make cert` | Generate self-signed dev TLS cert in `certs/` (valid 365 days) |
+| `make clean` | Remove build artifacts |
+| `make tidy` | Tidy and verify Go module dependencies |
+| `make run ARGS="..."` | Build then run with custom args |
+| `make help` | List all targets |
+
+## TLS
+
+nib supports TLS via `--tls-cert` and `--tls-key` flags on the `serve` command.
+
+### Dev (self-signed)
+
+```sh
+make cert
+make run ARGS="serve --tls-cert certs/dev.crt --tls-key certs/dev.key"
+```
+
+Serves HTTPS on port 4443. Browser will warn about the self-signed cert — accept once.
+
+This is needed for features that require a secure context (e.g. clipboard API).
+
+### Production
+
+For production, use a reverse proxy (Caddy, nginx) with real certificates in front of nib's HTTP server. Alternatively, pass real cert/key paths directly:
+
+```sh
+./nib serve --tls-cert /path/to/cert.pem --tls-key /path/to/key.pem
+```
+
+### Port Defaults
+
+| Mode | Default Port |
+|------|-------------|
+| HTTP | 4444 |
+| HTTPS | 4443 |
+
+Override with `--port` or the `NIB_PORT` environment variable.
+
+## Terminal UI
+
+Run the TUI directly from source:
+
+```sh
+go run . tui
+```
+
+TUI code lives in `internal/tui/`. No live-reload — restart manually after changes.
+
+## Typical Workflow
+
+1. `make cert` — once, generates dev TLS cert
+2. `make watch` — start coding, air rebuilds on save
+3. Edit code, save, changes appear automatically
+4. `make test` — verify nothing broke
+5. `make lint` — check formatting and vet
+6. Commit and push

go.mod

@@ -3,21 +3,45 @@ module github.com/lerko/nib
 go 1.24.4
 
 require (
-	github.com/atotto/clipboard v0.1.4 // indirect
+	github.com/atotto/clipboard v0.1.4
+	github.com/charmbracelet/bubbles v1.0.0
+	github.com/charmbracelet/bubbletea v1.3.10
+	github.com/charmbracelet/lipgloss v1.1.0
+	github.com/go-chi/chi/v5 v5.2.5
+	github.com/oklog/ulid/v2 v2.1.1
+	github.com/spf13/cobra v1.10.2
+	modernc.org/sqlite v1.37.1
+)
+
+require (
+	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
+	github.com/charmbracelet/colorprofile v0.4.1 // indirect
+	github.com/charmbracelet/x/ansi v0.11.6 // indirect
+	github.com/charmbracelet/x/cellbuf v0.0.15 // indirect
+	github.com/charmbracelet/x/term v0.2.2 // indirect
+	github.com/clipperhouse/displaywidth v0.9.0 // indirect
+	github.com/clipperhouse/stringish v0.1.1 // indirect
+	github.com/clipperhouse/uax29/v2 v2.5.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/go-chi/chi/v5 v5.2.5 // indirect
+	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-localereader v0.0.1 // indirect
+	github.com/mattn/go-runewidth v0.0.19 // indirect
+	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/ncruces/go-strftime v0.1.9 // indirect
-	github.com/oklog/ulid/v2 v2.1.1 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
-	github.com/spf13/cobra v1.10.2 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/spf13/pflag v1.0.9 // indirect
+	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect
-	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/sys v0.38.0 // indirect
+	golang.org/x/text v0.3.8 // indirect
 	modernc.org/libc v1.65.7 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect
-	modernc.org/sqlite v1.37.1 // indirect
 )

go.sum

@@ -1,16 +1,54 @@
 github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
 github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
+github.com/charmbracelet/bubbles v1.0.0 h1:12J8/ak/uCZEMQ6KU7pcfwceyjLlWsDLAxB5fXonfvc=
+github.com/charmbracelet/bubbles v1.0.0/go.mod h1:9d/Zd5GdnauMI5ivUIVisuEm3ave1XwXtD1ckyV6r3E=
+github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw=
+github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4=
+github.com/charmbracelet/colorprofile v0.4.1 h1:a1lO03qTrSIRaK8c3JRxJDZOvhvIeSco3ej+ngLk1kk=
+github.com/charmbracelet/colorprofile v0.4.1/go.mod h1:U1d9Dljmdf9DLegaJ0nGZNJvoXAhayhmidOdcBwAvKk=
+github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
+github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
+github.com/charmbracelet/x/ansi v0.11.6 h1:GhV21SiDz/45W9AnV2R61xZMRri5NlLnl6CVF7ihZW8=
+github.com/charmbracelet/x/ansi v0.11.6/go.mod h1:2JNYLgQUsyqaiLovhU2Rv/pb8r6ydXKS3NIttu3VGZQ=
+github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMxoFPAIztPI=
+github.com/charmbracelet/x/cellbuf v0.0.15/go.mod h1:J1YVbR7MUuEGIFPCaaZ96KDl5NoS0DAWkskup+mOY+Q=
+github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk=
+github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI=
+github.com/clipperhouse/displaywidth v0.9.0 h1:Qb4KOhYwRiN3viMv1v/3cTBlz3AcAZX3+y9OLhMtAtA=
+github.com/clipperhouse/displaywidth v0.9.0/go.mod h1:aCAAqTlh4GIVkhQnJpbL0T/WfcrJXHcj8C0yjYcjOZA=
+github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
+github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
+github.com/clipperhouse/uax29/v2 v2.5.0 h1:x7T0T4eTHDONxFJsL94uKNKPHrclyFI0lm7+w94cO8U=
+github.com/clipperhouse/uax29/v2 v2.5.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
 github.com/go-chi/chi/v5 v5.2.5 h1:Eg4myHZBjyvJmAFjFvWgrqDTXFyOzjj7YIm3L3mu6Ug=
 github.com/go-chi/chi/v5 v5.2.5/go.mod h1:X7Gx4mteadT3eDOMTsXzmI4/rwUpOwBHLpAfupzFJP0=
+github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
+github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=
+github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
+github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
+github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
+github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
+github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
+github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
 github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
 github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/oklog/ulid/v2 v2.1.1 h1:suPZ4ARWLOJLegGFiZZ1dFAkqzhMjL3J1TzI+5wHz8s=
@@ -18,23 +56,52 @@ github.com/oklog/ulid/v2 v2.1.1/go.mod h1:rcEKHmBBKfef9DhnvX7y1HZBYxjXb0cP5ExxNs
 github.com/pborman/getopt v0.0.0-20170112200414-7148bc3a4c30/go.mod h1:85jBQOZwpVEaDAr341tbn15RS4fCAsIst0qp7i8ex1o=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
 github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
 github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM=
 golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8=
+golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=
+golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
+golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
+golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc=
+golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+modernc.org/cc/v4 v4.26.1 h1:+X5NtzVBn0KgsBCBe+xkDC7twLb/jNVj9FPgiwSQO3s=
+modernc.org/cc/v4 v4.26.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=
+modernc.org/ccgo/v4 v4.28.0/go.mod h1:JygV3+9AV6SmPhDasu4JgquwU81XAKLd3OKTUDNOiKE=
+modernc.org/fileutil v1.3.1 h1:8vq5fe7jdtEvoCf3Zf9Nm0Q05sH6kGx0Op2CPx1wTC8=
+modernc.org/fileutil v1.3.1/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
+modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
+modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
 modernc.org/libc v1.65.7 h1:Ia9Z4yzZtWNtUIuiPuQ7Qf7kxYrxP1/jeHZzG8bFu00=
 modernc.org/libc v1.65.7/go.mod h1:011EQibzzio/VX3ygj1qGFt5kMjP0lHb0qCW5/D/pQU=
 modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
 modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
 modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
 modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
+modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
+modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
+modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
+modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
 modernc.org/sqlite v1.37.1 h1:EgHJK/FPoqC+q2YBXg7fUmES37pCHFc97sI7zSayBEs=
 modernc.org/sqlite v1.37.1/go.mod h1:XwdRtsE1MpiBcL54+MbKcaDvcuej+IYSMfLN6gSKV8g=
+modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
+modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
+modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
+modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=

internal/api/api_test.go

@@ -25,15 +25,36 @@ func testServer(t *testing.T) (*httptest.Server, *db.Store) {
 	return srv, store
 }
 
-func postJSON(srv *httptest.Server, path string, body any) *http.Response {
+type listEnvelope struct {
-	b, _ := json.Marshal(body)
+	Data   []EntityResponse `json:"data"`
-	resp, _ := http.Post(srv.URL+path, "application/json", bytes.NewReader(b))
+	Total  int              `json:"total"`
+	Limit  int              `json:"limit"`
+	Offset int              `json:"offset"`
+}
+
+func decodeList(t *testing.T, resp *http.Response) []EntityResponse {
+	t.Helper()
+	var env listEnvelope
+	json.NewDecoder(resp.Body).Decode(&env)
+	return env.Data
+}
+
+func postJSON(t *testing.T, srv *httptest.Server, path string, body any) *http.Response {
+	t.Helper()
+	b, err := json.Marshal(body)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err := http.Post(srv.URL+path, "application/json", bytes.NewReader(b))
+	if err != nil {
+		t.Fatal(err)
+	}
 	return resp
 }
 
 func createTestEntity(t *testing.T, srv *httptest.Server, body string, tags []string) EntityResponse {
 	t.Helper()
-	resp := postJSON(srv, "/api/entities", map[string]any{
+	resp := postJSON(t, srv, "/api/entities", map[string]any{
 		"body": body,
 		"tags": tags,
 	})
@@ -49,7 +70,7 @@ func createTestEntity(t *testing.T, srv *httptest.Server, body string, tags []st
 func TestCreateEntity_Note(t *testing.T) {
 	srv, _ := testServer(t)
 
-	resp := postJSON(srv, "/api/entities", map[string]any{
+	resp := postJSON(t, srv, "/api/entities", map[string]any{
 		"body": "test note",
 		"tags": []string{"demo"},
 	})
@@ -76,7 +97,7 @@ func TestCreateEntity_Note(t *testing.T) {
 func TestCreateEntity_MissingBody(t *testing.T) {
 	srv, _ := testServer(t)
 
-	resp := postJSON(srv, "/api/entities", map[string]any{})
+	resp := postJSON(t, srv, "/api/entities", map[string]any{})
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusBadRequest {
@@ -93,7 +114,7 @@ func TestCreateEntity_MissingBody(t *testing.T) {
 func TestCreateEntity_InvalidGlyph(t *testing.T) {
 	srv, _ := testServer(t)
 
-	resp := postJSON(srv, "/api/entities", map[string]any{
+	resp := postJSON(t, srv, "/api/entities", map[string]any{
 		"body":  "test",
 		"glyph": "invalid",
 	})
@@ -108,7 +129,10 @@ func TestGetEntity_Success(t *testing.T) {
 	srv, _ := testServer(t)
 	created := createTestEntity(t, srv, "test", nil)
 
-	resp, _ := http.Get(srv.URL + "/api/entities/" + created.ID)
+	resp, err := http.Get(srv.URL + "/api/entities/" + created.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
@@ -125,7 +149,10 @@ func TestGetEntity_Success(t *testing.T) {
 func TestGetEntity_NotFound(t *testing.T) {
 	srv, _ := testServer(t)
 
-	resp, _ := http.Get(srv.URL + "/api/entities/NONEXISTENT")
+	resp, err := http.Get(srv.URL + "/api/entities/NONEXISTENT")
+	if err != nil {
+		t.Fatal(err)
+	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusNotFound {
@@ -138,11 +165,13 @@ func TestListEntities_Default(t *testing.T) {
 	createTestEntity(t, srv, "one", nil)
 	createTestEntity(t, srv, "two", nil)
 
-	resp, _ := http.Get(srv.URL + "/api/entities")
+	resp, err := http.Get(srv.URL + "/api/entities")
+	if err != nil {
+		t.Fatal(err)
+	}
 	defer resp.Body.Close()
 
-	var entities []EntityResponse
+	entities := decodeList(t, resp)
-	json.NewDecoder(resp.Body).Decode(&entities)
 	if len(entities) != 2 {
 		t.Fatalf("expected 2, got %d", len(entities))
 	}
@@ -153,11 +182,13 @@ func TestListEntities_FilterTag(t *testing.T) {
 	createTestEntity(t, srv, "a", []string{"ops"})
 	createTestEntity(t, srv, "b", []string{"home"})
 
-	resp, _ := http.Get(srv.URL + "/api/entities?tag=ops")
+	resp, err := http.Get(srv.URL + "/api/entities?tag=ops")
+	if err != nil {
+		t.Fatal(err)
+	}
 	defer resp.Body.Close()
 
-	var entities []EntityResponse
+	entities := decodeList(t, resp)
-	json.NewDecoder(resp.Body).Decode(&entities)
 	if len(entities) != 1 {
 		t.Fatalf("expected 1, got %d", len(entities))
 	}
@@ -167,17 +198,19 @@ func TestListEntities_CardsOnly(t *testing.T) {
 	srv, _ := testServer(t)
 	createTestEntity(t, srv, "fluid", nil)
 
-	resp := postJSON(srv, "/api/entities", map[string]any{
+	resp := postJSON(t, srv, "/api/entities", map[string]any{
 		"body":      "card",
 		"card_type": "snippet",
 	})
 	resp.Body.Close()
 
-	resp, _ = http.Get(srv.URL + "/api/entities?cards_only=true")
+	resp, err := http.Get(srv.URL + "/api/entities?cards_only=true")
+	if err != nil {
+		t.Fatal(err)
+	}
 	defer resp.Body.Close()
 
-	var entities []EntityResponse
+	entities := decodeList(t, resp)
-	json.NewDecoder(resp.Body).Decode(&entities)
 	if len(entities) != 1 {
 		t.Fatalf("expected 1 card, got %d", len(entities))
 	}
@@ -189,14 +222,18 @@ func TestListEntities_Pagination(t *testing.T) {
 		createTestEntity(t, srv, "note", nil)
 	}
 
-	resp, _ := http.Get(srv.URL + "/api/entities?limit=2&offset=0")
+	resp, err := http.Get(srv.URL + "/api/entities?limit=2&offset=0")
-	var page1 []EntityResponse
+	if err != nil {
-	json.NewDecoder(resp.Body).Decode(&page1)
+		t.Fatal(err)
+	}
+	page1 := decodeList(t, resp)
 	resp.Body.Close()
 
-	resp, _ = http.Get(srv.URL + "/api/entities?limit=2&offset=2")
+	resp, err = http.Get(srv.URL + "/api/entities?limit=2&offset=2")
-	var page2 []EntityResponse
+	if err != nil {
-	json.NewDecoder(resp.Body).Decode(&page2)
+		t.Fatal(err)
+	}
+	page2 := decodeList(t, resp)
 	resp.Body.Close()
 
 	if len(page1) != 2 || len(page2) != 2 {
@@ -211,10 +248,16 @@ func TestUpdateEntity_Body(t *testing.T) {
 	srv, _ := testServer(t)
 	created := createTestEntity(t, srv, "old", nil)
 
-	req, _ := http.NewRequest("PUT", srv.URL+"/api/entities/"+created.ID, bytes.NewReader(
+	req, err := http.NewRequest("PUT", srv.URL+"/api/entities/"+created.ID, bytes.NewReader(
 		mustJSON(map[string]any{"body": "new"})))
+	if err != nil {
+		t.Fatal(err)
+	}
 	req.Header.Set("Content-Type", "application/json")
-	resp, _ := http.DefaultClient.Do(req)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
@@ -233,8 +276,14 @@ func TestDeleteEntity_SoftThenHard(t *testing.T) {
 	created := createTestEntity(t, srv, "doomed", nil)
 
 	// Soft delete
-	req, _ := http.NewRequest("DELETE", srv.URL+"/api/entities/"+created.ID, nil)
+	req, err := http.NewRequest("DELETE", srv.URL+"/api/entities/"+created.ID, nil)
-	resp, _ := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
 	var delResp DeleteResponse
 	json.NewDecoder(resp.Body).Decode(&delResp)
 	resp.Body.Close()
@@ -246,7 +295,14 @@ func TestDeleteEntity_SoftThenHard(t *testing.T) {
 	}
 
 	// Hard delete
-	resp, _ = http.DefaultClient.Do(req)
+	req, err = http.NewRequest("DELETE", srv.URL+"/api/entities/"+created.ID, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
 	json.NewDecoder(resp.Body).Decode(&delResp)
 	resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
@@ -257,7 +313,10 @@ func TestDeleteEntity_SoftThenHard(t *testing.T) {
 	}
 
 	// Gone
-	resp, _ = http.Get(srv.URL + "/api/entities/" + created.ID)
+	resp, err = http.Get(srv.URL + "/api/entities/" + created.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
 	resp.Body.Close()
 	if resp.StatusCode != http.StatusNotFound {
 		t.Fatalf("expected 404 after hard delete, got %d", resp.StatusCode)
@@ -268,7 +327,7 @@ func TestPromoteEntity_Success(t *testing.T) {
 	srv, _ := testServer(t)
 	created := createTestEntity(t, srv, "trick", nil)
 
-	resp := postJSON(srv, "/api/entities/"+created.ID+"/promote", map[string]any{
+	resp := postJSON(t, srv, "/api/entities/"+created.ID+"/promote", map[string]any{
 		"card_type": "snippet",
 	})
 	defer resp.Body.Close()
@@ -288,11 +347,11 @@ func TestPromoteEntity_AlreadyPromoted(t *testing.T) {
 	srv, _ := testServer(t)
 	created := createTestEntity(t, srv, "trick", nil)
 
-	postJSON(srv, "/api/entities/"+created.ID+"/promote", map[string]any{
+	postJSON(t, srv, "/api/entities/"+created.ID+"/promote", map[string]any{
 		"card_type": "snippet",
 	}).Body.Close()
 
-	resp := postJSON(srv, "/api/entities/"+created.ID+"/promote", map[string]any{
+	resp := postJSON(t, srv, "/api/entities/"+created.ID+"/promote", map[string]any{
 		"card_type": "template",
 	})
 	defer resp.Body.Close()
@@ -312,7 +371,7 @@ func TestPromoteEntity_InvalidType(t *testing.T) {
 	srv, _ := testServer(t)
 	created := createTestEntity(t, srv, "trick", nil)
 
-	resp := postJSON(srv, "/api/entities/"+created.ID+"/promote", map[string]any{
+	resp := postJSON(t, srv, "/api/entities/"+created.ID+"/promote", map[string]any{
 		"card_type": "bogus",
 	})
 	defer resp.Body.Close()
@@ -326,11 +385,11 @@ func TestDemoteEntity_Success(t *testing.T) {
 	srv, _ := testServer(t)
 	created := createTestEntity(t, srv, "trick", nil)
 
-	postJSON(srv, "/api/entities/"+created.ID+"/promote", map[string]any{
+	postJSON(t, srv, "/api/entities/"+created.ID+"/promote", map[string]any{
 		"card_type": "snippet",
 	}).Body.Close()
 
-	resp := postJSON(srv, "/api/entities/"+created.ID+"/demote", nil)
+	resp := postJSON(t, srv, "/api/entities/"+created.ID+"/demote", nil)
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
@@ -348,7 +407,7 @@ func TestDemoteEntity_AlreadyFluid(t *testing.T) {
 	srv, _ := testServer(t)
 	created := createTestEntity(t, srv, "trick", nil)
 
-	resp := postJSON(srv, "/api/entities/"+created.ID+"/demote", nil)
+	resp := postJSON(t, srv, "/api/entities/"+created.ID+"/demote", nil)
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusBadRequest {
@@ -360,7 +419,7 @@ func TestUseEntity_Success(t *testing.T) {
 	srv, _ := testServer(t)
 	created := createTestEntity(t, srv, "trick", nil)
 
-	resp := postJSON(srv, "/api/entities/"+created.ID+"/use", nil)
+	resp := postJSON(t, srv, "/api/entities/"+created.ID+"/use", nil)
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
@@ -379,7 +438,10 @@ func TestListTags_WithCounts(t *testing.T) {
 	createTestEntity(t, srv, "a", []string{"ops"})
 	createTestEntity(t, srv, "b", []string{"ops", "nginx"})
 
-	resp, _ := http.Get(srv.URL + "/api/tags")
+	resp, err := http.Get(srv.URL + "/api/tags")
+	if err != nil {
+		t.Fatal(err)
+	}
 	defer resp.Body.Close()
 
 	var tags []TagResponse
@@ -391,14 +453,23 @@ func TestListTags_WithCounts(t *testing.T) {
 
 func TestCORS_DevMode(t *testing.T) {
 	path := filepath.Join(t.TempDir(), "test.db")
-	store, _ := db.Open(path)
+	store, err := db.Open(path)
+	if err != nil {
+		t.Fatal(err)
+	}
 	defer store.Close()
 	router := NewRouter(store, true)
 	srv := httptest.NewServer(router)
 	defer srv.Close()
 
-	req, _ := http.NewRequest("OPTIONS", srv.URL+"/api/entities", nil)
+	req, err := http.NewRequest("OPTIONS", srv.URL+"/api/entities", nil)
-	resp, _ := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
 	defer resp.Body.Close()
 
 	if resp.Header.Get("Access-Control-Allow-Origin") != "*" {
@@ -412,8 +483,14 @@ func TestCORS_DevMode(t *testing.T) {
 func TestCORS_ProdMode(t *testing.T) {
 	srv, _ := testServer(t) // devMode=false
 
-	req, _ := http.NewRequest("OPTIONS", srv.URL+"/api/entities", nil)
+	req, err := http.NewRequest("OPTIONS", srv.URL+"/api/entities", nil)
-	resp, _ := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
 	defer resp.Body.Close()
 
 	if resp.Header.Get("Access-Control-Allow-Origin") != "" {
@@ -426,7 +503,7 @@ func TestAbsorbEntity_Success(t *testing.T) {
 	target := createTestEntity(t, srv, "target body", []string{"ops"})
 	source := createTestEntity(t, srv, "source body", []string{"ops", "infra"})
 
-	resp := postJSON(srv, "/api/entities/"+target.ID+"/absorb", map[string]any{
+	resp := postJSON(t, srv, "/api/entities/"+target.ID+"/absorb", map[string]any{
 		"source_id": source.ID,
 	})
 	defer resp.Body.Close()
@@ -445,9 +522,11 @@ func TestAbsorbEntity_Success(t *testing.T) {
 	}
 
 	// Source should be soft-deleted (not in default list)
-	listResp, _ := http.Get(srv.URL + "/api/entities")
+	listResp, err := http.Get(srv.URL + "/api/entities")
-	var entities []EntityResponse
+	if err != nil {
-	json.NewDecoder(listResp.Body).Decode(&entities)
+		t.Fatal(err)
+	}
+	entities := decodeList(t, listResp)
 	listResp.Body.Close()
 	for _, ent := range entities {
 		if ent.ID == source.ID {
@@ -461,11 +540,11 @@ func TestAbsorbEntity_TargetCrystallized(t *testing.T) {
 	target := createTestEntity(t, srv, "target", nil)
 	source := createTestEntity(t, srv, "source", nil)
 
-	postJSON(srv, "/api/entities/"+target.ID+"/promote", map[string]any{
+	postJSON(t, srv, "/api/entities/"+target.ID+"/promote", map[string]any{
 		"card_type": "snippet",
 	}).Body.Close()
 
-	resp := postJSON(srv, "/api/entities/"+target.ID+"/absorb", map[string]any{
+	resp := postJSON(t, srv, "/api/entities/"+target.ID+"/absorb", map[string]any{
 		"source_id": source.ID,
 	})
 	defer resp.Body.Close()
@@ -485,7 +564,7 @@ func TestAbsorbEntity_SameEntity(t *testing.T) {
 	srv, _ := testServer(t)
 	e := createTestEntity(t, srv, "self", nil)
 
-	resp := postJSON(srv, "/api/entities/"+e.ID+"/absorb", map[string]any{
+	resp := postJSON(t, srv, "/api/entities/"+e.ID+"/absorb", map[string]any{
 		"source_id": e.ID,
 	})
 	defer resp.Body.Close()
@@ -499,7 +578,7 @@ func TestAbsorbEntity_MissingSourceID(t *testing.T) {
 	srv, _ := testServer(t)
 	e := createTestEntity(t, srv, "target", nil)
 
-	resp := postJSON(srv, "/api/entities/"+e.ID+"/absorb", map[string]any{})
+	resp := postJSON(t, srv, "/api/entities/"+e.ID+"/absorb", map[string]any{})
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusBadRequest {
@@ -507,6 +586,123 @@ func TestAbsorbEntity_MissingSourceID(t *testing.T) {
 	}
 }
 
+func TestCreateEntity_WithTitle(t *testing.T) {
+	srv, _ := testServer(t)
+
+	resp := postJSON(t, srv, "/api/entities", map[string]any{
+		"body":        "body text",
+		"title":       "nginx trick",
+		"description": "always forget this",
+		"tags":        []string{"ops"},
+	})
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusCreated {
+		t.Fatalf("expected 201, got %d", resp.StatusCode)
+	}
+
+	var e EntityResponse
+	json.NewDecoder(resp.Body).Decode(&e)
+	if e.Title == nil || *e.Title != "nginx trick" {
+		t.Errorf("title: %v", e.Title)
+	}
+	if e.Description == nil || *e.Description != "always forget this" {
+		t.Errorf("description: %v", e.Description)
+	}
+}
+
+func TestCreateEntity_TitleOnly(t *testing.T) {
+	srv, _ := testServer(t)
+
+	title := "title only"
+	resp := postJSON(t, srv, "/api/entities", map[string]any{
+		"title": title,
+	})
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusCreated {
+		t.Fatalf("expected 201, got %d", resp.StatusCode)
+	}
+
+	var e EntityResponse
+	json.NewDecoder(resp.Body).Decode(&e)
+	if e.Title == nil || *e.Title != "title only" {
+		t.Errorf("title: %v", e.Title)
+	}
+}
+
+func TestUpdateEntity_Title(t *testing.T) {
+	srv, _ := testServer(t)
+	created := createTestEntity(t, srv, "body", nil)
+
+	req, _ := http.NewRequest("PUT", srv.URL+"/api/entities/"+created.ID, bytes.NewReader(
+		mustJSON(map[string]any{"title": "new title"})))
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("expected 200, got %d", resp.StatusCode)
+	}
+
+	var e EntityResponse
+	json.NewDecoder(resp.Body).Decode(&e)
+	if e.Title == nil || *e.Title != "new title" {
+		t.Errorf("title: %v", e.Title)
+	}
+}
+
+func TestUpdateEntity_Description(t *testing.T) {
+	srv, _ := testServer(t)
+	created := createTestEntity(t, srv, "body", nil)
+
+	req, _ := http.NewRequest("PUT", srv.URL+"/api/entities/"+created.ID, bytes.NewReader(
+		mustJSON(map[string]any{"description": "new desc"})))
+	req.Header.Set("Content-Type", "application/json")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("expected 200, got %d", resp.StatusCode)
+	}
+
+	var e EntityResponse
+	json.NewDecoder(resp.Body).Decode(&e)
+	if e.Description == nil || *e.Description != "new desc" {
+		t.Errorf("description: %v", e.Description)
+	}
+}
+
+func TestListEntities_TitleInResponse(t *testing.T) {
+	srv, _ := testServer(t)
+
+	title := "list title"
+	postJSON(t, srv, "/api/entities", map[string]any{
+		"body":  "body",
+		"title": title,
+	}).Body.Close()
+
+	resp, err := http.Get(srv.URL + "/api/entities")
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	defer resp.Body.Close()
+
+	entities := decodeList(t, resp)
+	if len(entities) != 1 {
+		t.Fatalf("expected 1, got %d", len(entities))
+	}
+	if entities[0].Title == nil || *entities[0].Title != "list title" {
+		t.Errorf("title: %v", entities[0].Title)
+	}
+}
+
 func mustJSON(v any) []byte {
 	b, _ := json.Marshal(v)
 	return b

internal/api/entities.go

@@ -11,15 +11,20 @@ import (
 
 type CreateEntityRequest struct {
 	Body        string   `json:"body"`
+	Title       *string  `json:"title"`
+	Description *string  `json:"description"`
 	Glyph       *string  `json:"glyph"`
 	TimeAnchor  *string  `json:"time_anchor"`
 	Tags        []string `json:"tags"`
+	Pinned      *bool    `json:"pinned"`
 	CardType    *string  `json:"card_type"`
 	CardData    *string  `json:"card_data"`
 }
 
 type UpdateEntityRequest struct {
 	Body        *string   `json:"body"`
+	Title       *string   `json:"title"`
+	Description *string   `json:"description"`
 	Glyph       *string   `json:"glyph"`
 	TimeAnchor  *string   `json:"time_anchor"`
 	Tags        *[]string `json:"tags"`
@@ -97,18 +102,32 @@ func listEntities(store *db.Store) http.HandlerFunc {
 			}
 			p.Offset = offset
 		}
+		if p.Limit <= 0 {
+			p.Limit = 50
+		}
 
-		entities, err := store.List(p)
+		total, err := store.Count(p)
 		if err != nil {
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 
-		resp := make([]EntityResponse, len(entities))
+		entities, err := store.List(p)
-		for i, e := range entities {
+		if err != nil {
-			resp[i] = entityToResponse(e)
+			writeInternalError(w, err)
+			return
 		}
-		writeJSON(w, http.StatusOK, resp)
+
+		items := make([]EntityResponse, len(entities))
+		for i, e := range entities {
+			items[i] = entityToResponse(e)
+		}
+		writeJSON(w, http.StatusOK, map[string]any{
+			"data":   items,
+			"total":  total,
+			"limit":  p.Limit,
+			"offset": p.Offset,
+		})
 	}
 }
 
@@ -119,8 +138,8 @@ func createEntity(store *db.Store) http.HandlerFunc {
 			return
 		}
 
-		if req.Body == "" {
+		if req.Body == "" && req.Title == nil {
-			writeError(w, http.StatusBadRequest, "invalid_input", "body is required")
+			writeError(w, http.StatusBadRequest, "invalid_input", "body or title is required")
 			return
 		}
 
@@ -135,10 +154,15 @@ func createEntity(store *db.Store) http.HandlerFunc {
 
 		e := &db.Entity{
 			Body:        req.Body,
+			Title:       req.Title,
+			Description: req.Description,
 			Glyph:       glyph,
 			TimeAnchor:  req.TimeAnchor,
 			Tags:        req.Tags,
 		}
+		if req.Pinned != nil && *req.Pinned {
+			e.Pinned = true
+		}
 
 		if req.CardType != nil {
 			if !db.ValidCardType(*req.CardType) {
@@ -151,7 +175,11 @@ func createEntity(store *db.Store) http.HandlerFunc {
 		}
 
 		if err := store.Create(e); err != nil {
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			if err == db.ErrInvalidCardData {
+				writeError(w, http.StatusBadRequest, "invalid_card_data", "card_data must be valid JSON")
+				return
+			}
+			writeInternalError(w, err)
 			return
 		}
 
@@ -168,7 +196,7 @@ func getEntity(store *db.Store) http.HandlerFunc {
 				writeError(w, http.StatusNotFound, "not_found", "no entity with id "+id)
 				return
 			}
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, entityToResponse(e))
@@ -186,6 +214,8 @@ func updateEntity(store *db.Store) http.HandlerFunc {
 
 		u := &db.EntityUpdate{}
 		u.Body = req.Body
+		u.Title = req.Title
+		u.Description = req.Description
 		u.Tags = req.Tags
 		u.Pinned = req.Pinned
 		u.CardData = req.CardData
@@ -215,13 +245,17 @@ func updateEntity(store *db.Store) http.HandlerFunc {
 				writeError(w, http.StatusNotFound, "not_found", "no entity with id "+id)
 				return
 			}
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			if err == db.ErrInvalidCardData {
+				writeError(w, http.StatusBadRequest, "invalid_card_data", "card_data must be valid JSON")
+				return
+			}
+			writeInternalError(w, err)
 			return
 		}
 
 		e, err := store.Get(id)
 		if err != nil {
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, entityToResponse(e))
@@ -241,7 +275,7 @@ func deleteEntity(store *db.Store) http.HandlerFunc {
 				writeError(w, http.StatusNotFound, "not_found", "no entity with id "+id)
 				return
 			}
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 		label := "soft"
@@ -279,13 +313,17 @@ func promoteEntity(store *db.Store) http.HandlerFunc {
 				writeError(w, http.StatusBadRequest, "invalid_promote", "entity is already crystallized")
 				return
 			}
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			if err == db.ErrInvalidCardData {
+				writeError(w, http.StatusBadRequest, "invalid_card_data", "card_data must be valid JSON")
+				return
+			}
+			writeInternalError(w, err)
 			return
 		}
 
 		e, err := store.Get(id)
 		if err != nil {
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, entityToResponse(e))
@@ -305,13 +343,13 @@ func demoteEntity(store *db.Store) http.HandlerFunc {
 				writeError(w, http.StatusBadRequest, "invalid_demote", "entity is already fluid")
 				return
 			}
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 
 		e, err := store.Get(id)
 		if err != nil {
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, entityToResponse(e))
@@ -349,13 +387,13 @@ func absorbEntity(store *db.Store) http.HandlerFunc {
 				writeError(w, http.StatusBadRequest, "invalid_absorb", "target is crystallized — demote first")
 				return
 			}
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 
 		e, err := store.Get(id)
 		if err != nil {
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, entityToResponse(e))
@@ -371,13 +409,13 @@ func useEntity(store *db.Store) http.HandlerFunc {
 				writeError(w, http.StatusNotFound, "not_found", "no entity with id "+id)
 				return
 			}
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 
 		e, err := store.Get(id)
 		if err != nil {
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 		writeJSON(w, http.StatusOK, entityToResponse(e))

internal/api/helpers.go

@@ -2,12 +2,15 @@ package api
 
 import (
 	"encoding/json"
+	"log"
 	"net/http"
 	"time"
 
 	"github.com/lerko/nib/internal/db"
 )
 
+const maxBodySize = 1 << 20 // 1 MB
+
 type ErrorResponse struct {
 	Error   string `json:"error"`
 	Message string `json:"message"`
@@ -18,6 +21,8 @@ type EntityResponse struct {
 	CreatedAt   string   `json:"created_at"`
 	ModifiedAt  string   `json:"modified_at"`
 	Body        string   `json:"body"`
+	Title       *string  `json:"title"`
+	Description *string  `json:"description"`
 	Glyph       string   `json:"glyph"`
 	TimeAnchor  *string  `json:"time_anchor"`
 	CompletedAt *string  `json:"completed_at"`
@@ -41,6 +46,7 @@ func writeError(w http.ResponseWriter, status int, code, message string) {
 }
 
 func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
+	r.Body = http.MaxBytesReader(w, r.Body, maxBodySize)
 	if err := json.NewDecoder(r.Body).Decode(dst); err != nil {
 		writeError(w, http.StatusBadRequest, "invalid_input", "malformed JSON: "+err.Error())
 		return false
@@ -48,12 +54,19 @@ func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
 	return true
 }
 
+func writeInternalError(w http.ResponseWriter, err error) {
+	log.Printf("internal error: %v", err)
+	writeError(w, http.StatusInternalServerError, "internal", "internal server error")
+}
+
 func entityToResponse(e *db.Entity) EntityResponse {
 	resp := EntityResponse{
 		ID:          e.ID,
 		CreatedAt:   e.CreatedAt.Format(time.RFC3339),
 		ModifiedAt:  e.ModifiedAt.Format(time.RFC3339),
 		Body:        e.Body,
+		Title:       e.Title,
+		Description: e.Description,
 		Glyph:       string(e.Glyph),
 		Pinned:      e.Pinned,
 		Tags:        e.Tags,

internal/api/tags.go

@@ -13,9 +13,10 @@ type TagResponse struct {
 
 func listTags(store *db.Store) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		tags, err := store.ListTags()
+		cardsOnly := r.URL.Query().Get("cards_only") == "true"
+		tags, err := store.ListTags(cardsOnly)
 		if err != nil {
-			writeError(w, http.StatusInternalServerError, "internal", err.Error())
+			writeInternalError(w, err)
 			return
 		}
 

internal/carddata/carddata.go

@@ -0,0 +1,102 @@
+package carddata
+
+import (
+	"encoding/json"
+	"regexp"
+	"strings"
+
+	"github.com/lerko/nib/internal/db"
+)
+
+var TemplateSlotRe = regexp.MustCompile(`\$\{(\w+)\}`)
+
+func GenerateCardData(ct db.CardType, body string) *string {
+	var data string
+	switch ct {
+	case db.CardTemplate:
+		matches := TemplateSlotRe.FindAllStringSubmatch(body, -1)
+		type slot struct {
+			Name    string `json:"name"`
+			Default string `json:"default"`
+		}
+		var slots []slot
+		seen := map[string]bool{}
+		for _, m := range matches {
+			name := m[1]
+			if !seen[name] {
+				slots = append(slots, slot{Name: name, Default: ""})
+				seen[name] = true
+			}
+		}
+		if slots == nil {
+			slots = []slot{}
+		}
+		b, _ := json.Marshal(map[string]any{"slots": slots})
+		data = string(b)
+
+	case db.CardChecklist:
+		type step struct {
+			Text string `json:"text"`
+			Done bool   `json:"done"`
+		}
+		var steps []step
+		for _, line := range strings.Split(body, "\n") {
+			line = strings.TrimSpace(line)
+			if strings.HasPrefix(line, "[ ]") || strings.HasPrefix(line, "[x]") {
+				text := strings.TrimSpace(line[3:])
+				done := strings.HasPrefix(line, "[x]")
+				steps = append(steps, step{Text: text, Done: done})
+			}
+		}
+		if steps == nil {
+			steps = []step{{Text: body, Done: false}}
+		}
+		b, _ := json.Marshal(map[string]any{"steps": steps})
+		data = string(b)
+
+	case db.CardDecision:
+		b, _ := json.Marshal(map[string]any{
+			"chose":    "",
+			"why":      "",
+			"rejected": []string{},
+		})
+		data = string(b)
+
+	case db.CardLink:
+		url := ""
+		for _, word := range strings.Fields(body) {
+			if strings.HasPrefix(word, "http://") || strings.HasPrefix(word, "https://") {
+				url = word
+				break
+			}
+		}
+		b, _ := json.Marshal(map[string]any{"url": url})
+		data = string(b)
+
+	default:
+		data = "{}"
+	}
+	return &data
+}
+
+func DetectCardType(body string) *db.CardType {
+	if TemplateSlotRe.MatchString(body) {
+		ct := db.CardTemplate
+		return &ct
+	}
+	if strings.Contains(body, "chose:") || strings.Contains(body, "why:") {
+		ct := db.CardDecision
+		return &ct
+	}
+	if strings.Contains(body, "[ ]") || strings.Contains(body, "[x]") {
+		ct := db.CardChecklist
+		return &ct
+	}
+	for _, word := range strings.Fields(body) {
+		if strings.HasPrefix(word, "http://") || strings.HasPrefix(word, "https://") {
+			ct := db.CardLink
+			return &ct
+		}
+	}
+	return nil
+}

internal/carddata/carddata_test.go

@@ -0,0 +1,151 @@
+package carddata
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/lerko/nib/internal/db"
+)
+
+func TestGenerateCardData_Snippet(t *testing.T) {
+	data := GenerateCardData(db.CardSnippet, "some snippet")
+	if data == nil || *data != "{}" {
+		t.Errorf("snippet should produce {}, got %v", data)
+	}
+}
+
+func TestGenerateCardData_Template(t *testing.T) {
+	data := GenerateCardData(db.CardTemplate, "deploy ${host} to ${env}")
+	if data == nil {
+		t.Fatal("expected non-nil data")
+	}
+
+	var parsed struct {
+		Slots []struct {
+			Name    string `json:"name"`
+			Default string `json:"default"`
+		} `json:"slots"`
+	}
+	if err := json.Unmarshal([]byte(*data), &parsed); err != nil {
+		t.Fatal(err)
+	}
+	if len(parsed.Slots) != 2 {
+		t.Fatalf("expected 2 slots, got %d", len(parsed.Slots))
+	}
+	if parsed.Slots[0].Name != "host" {
+		t.Errorf("first slot: %q", parsed.Slots[0].Name)
+	}
+	if parsed.Slots[1].Name != "env" {
+		t.Errorf("second slot: %q", parsed.Slots[1].Name)
+	}
+}
+
+func TestGenerateCardData_TemplateDedupe(t *testing.T) {
+	data := GenerateCardData(db.CardTemplate, "${x} and ${x}")
+	var parsed struct {
+		Slots []struct {
+			Name string `json:"name"`
+		} `json:"slots"`
+	}
+	json.Unmarshal([]byte(*data), &parsed)
+	if len(parsed.Slots) != 1 {
+		t.Errorf("duplicate slots should be deduped, got %d", len(parsed.Slots))
+	}
+}
+
+func TestGenerateCardData_TemplateNoSlots(t *testing.T) {
+	data := GenerateCardData(db.CardTemplate, "no placeholders here")
+	var parsed struct {
+		Slots []struct {
+			Name string `json:"name"`
+		} `json:"slots"`
+	}
+	json.Unmarshal([]byte(*data), &parsed)
+	if len(parsed.Slots) != 0 {
+		t.Errorf("expected empty slots, got %d", len(parsed.Slots))
+	}
+}
+
+func TestGenerateCardData_Checklist(t *testing.T) {
+	body := "[ ] step one\n[x] step two\n[ ] step three"
+	data := GenerateCardData(db.CardChecklist, body)
+	if data == nil {
+		t.Fatal("expected non-nil data")
+	}
+
+	var parsed struct {
+		Steps []struct {
+			Text string `json:"text"`
+			Done bool   `json:"done"`
+		} `json:"steps"`
+	}
+	if err := json.Unmarshal([]byte(*data), &parsed); err != nil {
+		t.Fatal(err)
+	}
+	if len(parsed.Steps) != 3 {
+		t.Fatalf("expected 3 steps, got %d", len(parsed.Steps))
+	}
+	if parsed.Steps[0].Text != "step one" || parsed.Steps[0].Done {
+		t.Errorf("step 0: %+v", parsed.Steps[0])
+	}
+	if parsed.Steps[1].Text != "step two" || !parsed.Steps[1].Done {
+		t.Errorf("step 1: %+v", parsed.Steps[1])
+	}
+}
+
+func TestGenerateCardData_ChecklistFallback(t *testing.T) {
+	data := GenerateCardData(db.CardChecklist, "no checkbox syntax")
+	var parsed struct {
+		Steps []struct {
+			Text string `json:"text"`
+			Done bool   `json:"done"`
+		} `json:"steps"`
+	}
+	json.Unmarshal([]byte(*data), &parsed)
+	if len(parsed.Steps) != 1 {
+		t.Fatalf("fallback should produce 1 step, got %d", len(parsed.Steps))
+	}
+	if parsed.Steps[0].Text != "no checkbox syntax" {
+		t.Errorf("fallback step text: %q", parsed.Steps[0].Text)
+	}
+}
+
+func TestGenerateCardData_Decision(t *testing.T) {
+	data := GenerateCardData(db.CardDecision, "which db?")
+	var parsed struct {
+		Chose    string   `json:"chose"`
+		Why      string   `json:"why"`
+		Rejected []string `json:"rejected"`
+	}
+	if err := json.Unmarshal([]byte(*data), &parsed); err != nil {
+		t.Fatal(err)
+	}
+	if parsed.Chose != "" || parsed.Why != "" {
+		t.Error("decision fields should start empty")
+	}
+	if len(parsed.Rejected) != 0 {
+		t.Error("rejected should start empty")
+	}
+}
+
+func TestGenerateCardData_Link(t *testing.T) {
+	data := GenerateCardData(db.CardLink, "check https://example.com/path for details")
+	var parsed struct {
+		URL string `json:"url"`
+	}
+	json.Unmarshal([]byte(*data), &parsed)
+	if parsed.URL != "https://example.com/path" {
+		t.Errorf("url: %q", parsed.URL)
+	}
+}
+
+func TestGenerateCardData_LinkNoURL(t *testing.T) {
+	data := GenerateCardData(db.CardLink, "no url here")
+	var parsed struct {
+		URL string `json:"url"`
+	}
+	json.Unmarshal([]byte(*data), &parsed)
+	if parsed.URL != "" {
+		t.Errorf("expected empty url, got %q", parsed.URL)
+	}
+}

internal/db/db.go

@@ -3,6 +3,7 @@ package db
 import (
 	"database/sql"
 	"errors"
+	"fmt"
 	"os"
 	"path/filepath"
 
@@ -14,6 +15,7 @@ var (
 	ErrAlreadyPromoted    = errors.New("invalid_promote")
 	ErrAlreadyFluid       = errors.New("invalid_demote")
 	ErrTargetCrystallized = errors.New("invalid_absorb")
+	ErrInvalidCardData    = errors.New("invalid_card_data")
 )
 
 type Store struct {
@@ -49,22 +51,23 @@ func (s *Store) Close() error {
 	return s.db.Close()
 }
 
-func (s *Store) migrate() error {
+const currentSchema = 3
-	_, err := s.db.Exec(`
+
+var migrations = []func(db *sql.DB) error{
+	// v1: initial schema
+	func(db *sql.DB) error {
+		_, err := db.Exec(`
 			CREATE TABLE IF NOT EXISTS entities (
 				id          TEXT PRIMARY KEY,
 				created_at  TEXT NOT NULL,
 				modified_at TEXT NOT NULL,
 				body        TEXT NOT NULL,
-			glyph       TEXT NOT NULL
+				glyph       TEXT NOT NULL,
-				CHECK (glyph IN ('todo', 'event', 'note')),
 				time_anchor TEXT,
 				completed_at TEXT,
 				pinned      INTEGER NOT NULL DEFAULT 0,
 				deleted_at  TEXT,
-			card_type   TEXT
+				card_type   TEXT,
-				CHECK (card_type IN ('snippet', 'template', 'checklist', 'decision', 'link')
-				       OR card_type IS NULL),
 				card_data   TEXT,
 				use_count   INTEGER NOT NULL DEFAULT 0,
 				last_used_at TEXT
@@ -85,6 +88,107 @@ func (s *Store) migrate() error {
 				ON entity_tags(tag);
 		`)
 		return err
+	},
+
+	// v2: add title and description columns
+	func(db *sql.DB) error {
+		db.Exec(`ALTER TABLE entities ADD COLUMN title TEXT`)
+		db.Exec(`ALTER TABLE entities ADD COLUMN description TEXT`)
+		return nil
+	},
+
+	// v3: rebuild table with CHECK constraints (card_type 'note', glyph 'reminder')
+	func(db *sql.DB) error {
+		tx, err := db.Begin()
+		if err != nil {
+			return err
+		}
+		defer tx.Rollback()
+
+		// Disable FK checks during rebuild to avoid dangling references
+		if _, err := tx.Exec(`PRAGMA foreign_keys = OFF`); err != nil {
+			return fmt.Errorf("migrate fk off: %w", err)
+		}
+
+		if _, err := tx.Exec(`ALTER TABLE entities RENAME TO _entities_migrate`); err != nil {
+			return fmt.Errorf("migrate rename: %w", err)
+		}
+		if _, err := tx.Exec(`CREATE TABLE entities (
+			id          TEXT PRIMARY KEY,
+			created_at  TEXT NOT NULL,
+			modified_at TEXT NOT NULL,
+			body        TEXT NOT NULL,
+			glyph       TEXT NOT NULL
+				CHECK (glyph IN ('todo', 'event', 'note', 'reminder')),
+			time_anchor TEXT,
+			completed_at TEXT,
+			pinned      INTEGER NOT NULL DEFAULT 0,
+			deleted_at  TEXT,
+			card_type   TEXT
+				CHECK (card_type IN ('snippet', 'template', 'checklist', 'decision', 'link', 'note')
+				       OR card_type IS NULL),
+			card_data   TEXT,
+			use_count   INTEGER NOT NULL DEFAULT 0,
+			last_used_at TEXT,
+			title       TEXT,
+			description TEXT
+		)`); err != nil {
+			return fmt.Errorf("migrate create: %w", err)
+		}
+		if _, err := tx.Exec(`INSERT INTO entities SELECT * FROM _entities_migrate`); err != nil {
+			return fmt.Errorf("migrate copy: %w", err)
+		}
+		if _, err := tx.Exec(`DROP TABLE _entities_migrate`); err != nil {
+			return fmt.Errorf("migrate drop: %w", err)
+		}
+
+		// Rebuild entity_tags to point FK at new entities table
+		if _, err := tx.Exec(`ALTER TABLE entity_tags RENAME TO _tags_migrate`); err != nil {
+			return fmt.Errorf("migrate tags rename: %w", err)
+		}
+		if _, err := tx.Exec(`CREATE TABLE entity_tags (
+			entity_id TEXT NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+			tag       TEXT NOT NULL,
+			PRIMARY KEY (entity_id, tag)
+		)`); err != nil {
+			return fmt.Errorf("migrate tags create: %w", err)
+		}
+		if _, err := tx.Exec(`INSERT INTO entity_tags SELECT * FROM _tags_migrate`); err != nil {
+			return fmt.Errorf("migrate tags copy: %w", err)
+		}
+		if _, err := tx.Exec(`DROP TABLE _tags_migrate`); err != nil {
+			return fmt.Errorf("migrate tags drop: %w", err)
+		}
+
+		if _, err := tx.Exec(`PRAGMA foreign_keys = ON`); err != nil {
+			return fmt.Errorf("migrate fk on: %w", err)
+		}
+
+		return tx.Commit()
+	},
+}
+
+func (s *Store) migrate() error {
+	s.db.Exec(`CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL)`)
+
+	var version int
+	err := s.db.QueryRow(`SELECT version FROM schema_version`).Scan(&version)
+	if err != nil {
+		version = 0
+	}
+
+	for i := version; i < len(migrations); i++ {
+		if err := migrations[i](s.db); err != nil {
+			return fmt.Errorf("migration %d: %w", i+1, err)
+		}
+	}
+
+	if version == 0 {
+		_, err = s.db.Exec(`INSERT INTO schema_version (version) VALUES (?)`, len(migrations))
+	} else if len(migrations) > version {
+		_, err = s.db.Exec(`UPDATE schema_version SET version = ?`, len(migrations))
+	}
+	return err
 }
 
 func DefaultPath() (string, error) {

internal/db/entities.go

@@ -16,6 +16,7 @@ const (
 	GlyphNote     Glyph = "note"
 	GlyphTodo     Glyph = "todo"
 	GlyphEvent    Glyph = "event"
+	GlyphReminder Glyph = "reminder"
 )
 
 type CardType string
@@ -26,11 +27,12 @@ const (
 	CardChecklist CardType = "checklist"
 	CardDecision  CardType = "decision"
 	CardLink      CardType = "link"
+	CardNote      CardType = "note"
 )
 
 func ValidGlyph(s string) bool {
 	switch Glyph(s) {
-	case GlyphNote, GlyphTodo, GlyphEvent:
+	case GlyphNote, GlyphTodo, GlyphEvent, GlyphReminder:
 		return true
 	}
 	return false
@@ -38,7 +40,7 @@ func ValidGlyph(s string) bool {
 
 func ValidCardType(s string) bool {
 	switch CardType(s) {
-	case CardSnippet, CardTemplate, CardChecklist, CardDecision, CardLink:
+	case CardSnippet, CardTemplate, CardChecklist, CardDecision, CardLink, CardNote:
 		return true
 	}
 	return false
@@ -49,6 +51,8 @@ type Entity struct {
 	CreatedAt   time.Time
 	ModifiedAt  time.Time
 	Body        string
+	Title       *string
+	Description *string
 	Glyph       Glyph
 	TimeAnchor  *string
 	CompletedAt *time.Time
@@ -86,9 +90,13 @@ func DefaultListParams() ListParams {
 
 type EntityUpdate struct {
 	Body           *string
+	Title          *string
+	Description    *string
 	Glyph          *Glyph
 	TimeAnchor     *string
 	ClearTime      bool
+	CompletedAt    *time.Time
+	ClearCompleted bool
 	Pinned         *bool
 	CardType       *CardType
 	CardData       *string
@@ -96,6 +104,9 @@ type EntityUpdate struct {
 }
 
 func (s *Store) Create(e *Entity) error {
+	if e.CardData != nil && !json.Valid([]byte(*e.CardData)) {
+		return ErrInvalidCardData
+	}
 	now := time.Now().UTC()
 	e.ID = nibulid.New()
 	e.CreatedAt = now
@@ -111,13 +122,16 @@ func (s *Store) Create(e *Entity) error {
 	defer tx.Rollback()
 
 	_, err = tx.Exec(`
-		INSERT INTO entities (id, created_at, modified_at, body, glyph, time_anchor,
+		INSERT INTO entities (id, created_at, modified_at, body, title, description,
-			completed_at, pinned, deleted_at, card_type, card_data, use_count, last_used_at)
+			glyph, time_anchor, completed_at, pinned, deleted_at,
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			card_type, card_data, use_count, last_used_at)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 		e.ID,
 		e.CreatedAt.Format(time.RFC3339),
 		e.ModifiedAt.Format(time.RFC3339),
 		e.Body,
+		e.Title,
+		e.Description,
 		string(e.Glyph),
 		e.TimeAnchor,
 		formatTimePtr(e.CompletedAt),
@@ -141,18 +155,13 @@ func (s *Store) Create(e *Entity) error {
 
 func (s *Store) Get(id string) (*Entity, error) {
 	e := &Entity{}
-	var createdAt, modifiedAt string
+	row := newEntityRow()
-	var completedAt, deletedAt, lastUsedAt sql.NullString
-	var timeAnchor, cardType, cardData sql.NullString
-	var pinned int
 
 	err := s.db.QueryRow(`
-		SELECT id, created_at, modified_at, body, glyph, time_anchor,
+		SELECT id, created_at, modified_at, body, title, description,
-			completed_at, pinned, deleted_at, card_type, card_data, use_count, last_used_at
+			glyph, time_anchor, completed_at, pinned, deleted_at,
-		FROM entities WHERE id = ?`, id).Scan(
+			card_type, card_data, use_count, last_used_at
-		&e.ID, &createdAt, &modifiedAt, &e.Body, &e.Glyph, &timeAnchor,
+		FROM entities WHERE id = ?`, id).Scan(row.ptrs(e)...)
-		&completedAt, &pinned, &deletedAt, &cardType, &cardData, &e.UseCount, &lastUsedAt,
-	)
 	if err == sql.ErrNoRows {
 		return nil, ErrNotFound
 	}
@@ -160,15 +169,9 @@ func (s *Store) Get(id string) (*Entity, error) {
 		return nil, err
 	}
 
-	e.CreatedAt, _ = time.Parse(time.RFC3339, createdAt)
+	if err := row.apply(e); err != nil {
-	e.ModifiedAt, _ = time.Parse(time.RFC3339, modifiedAt)
+		return nil, fmt.Errorf("scan entity %s: %w", id, err)
-	e.TimeAnchor = nullToPtr(timeAnchor)
+	}
-	e.CompletedAt = parseTimePtr(completedAt)
-	e.Pinned = pinned != 0
-	e.DeletedAt = parseTimePtr(deletedAt)
-	e.CardType = nullToCardType(cardType)
-	e.CardData = nullToPtr(cardData)
-	e.LastUsedAt = parseTimePtr(lastUsedAt)
 
 	tags, err := s.loadTags(id)
 	if err != nil {
@@ -179,7 +182,7 @@ func (s *Store) Get(id string) (*Entity, error) {
 	return e, nil
 }
 
-func (s *Store) List(params ListParams) ([]*Entity, error) {
+func listWhere(params ListParams) (string, []any) {
 	var where []string
 	var args []any
 
@@ -214,18 +217,39 @@ func (s *Store) List(params ListParams) ([]*Entity, error) {
 		args = append(args, string(*params.CardTypeFilter))
 	}
 
-	whereClause := ""
+	clause := ""
 	if len(where) > 0 {
-		whereClause = "WHERE " + strings.Join(where, " AND ")
+		clause = "WHERE " + strings.Join(where, " AND ")
+	}
+	return clause, args
 }
 
+func (s *Store) Count(params ListParams) (int, error) {
+	whereClause, args := listWhere(params)
+	query := fmt.Sprintf("SELECT COUNT(*) FROM entities e %s", whereClause)
+	var count int
+	err := s.db.QueryRow(query, args...).Scan(&count)
+	return count, err
+}
+
+func (s *Store) List(params ListParams) ([]*Entity, error) {
+	whereClause, args := listWhere(params)
+
 	orderCol := "e.created_at"
-	if params.Sort == "use_count" {
+	switch params.Sort {
+	case "use_count":
 		orderCol = "e.use_count"
+	case "created_at", "":
+		orderCol = "e.created_at"
+	default:
+		orderCol = "e.created_at"
 	}
 	orderDir := "DESC"
-	if strings.EqualFold(params.Order, "asc") {
+	switch strings.ToLower(params.Order) {
+	case "asc":
 		orderDir = "ASC"
+	default:
+		orderDir = "DESC"
 	}
 
 	limit := params.Limit
@@ -234,9 +258,9 @@ func (s *Store) List(params ListParams) ([]*Entity, error) {
 	}
 
 	query := fmt.Sprintf(`
-		SELECT e.id, e.created_at, e.modified_at, e.body, e.glyph, e.time_anchor,
+		SELECT e.id, e.created_at, e.modified_at, e.body, e.title, e.description,
-			e.completed_at, e.pinned, e.deleted_at, e.card_type, e.card_data,
+			e.glyph, e.time_anchor, e.completed_at, e.pinned, e.deleted_at,
-			e.use_count, e.last_used_at
+			e.card_type, e.card_data, e.use_count, e.last_used_at
 		FROM entities e
 		%s
 		ORDER BY %s %s
@@ -253,31 +277,18 @@ func (s *Store) List(params ListParams) ([]*Entity, error) {
 	var entities []*Entity
 	for rows.Next() {
 		e := &Entity{}
-		var createdAt, modifiedAt string
+		row := newEntityRow()
-		var completedAt, deletedAt, lastUsedAt sql.NullString
+		if err := rows.Scan(row.ptrs(e)...); err != nil {
-		var timeAnchor, cardType, cardData sql.NullString
+			return nil, err
-		var pinned int
+		}
-
+		if err := row.apply(e); err != nil {
-		if err := rows.Scan(
-			&e.ID, &createdAt, &modifiedAt, &e.Body, &e.Glyph, &timeAnchor,
-			&completedAt, &pinned, &deletedAt, &cardType, &cardData,
-			&e.UseCount, &lastUsedAt,
-		); err != nil {
 			return nil, err
 		}
-
-		e.CreatedAt, _ = time.Parse(time.RFC3339, createdAt)
-		e.ModifiedAt, _ = time.Parse(time.RFC3339, modifiedAt)
-		e.TimeAnchor = nullToPtr(timeAnchor)
-		e.CompletedAt = parseTimePtr(completedAt)
-		e.Pinned = pinned != 0
-		e.DeletedAt = parseTimePtr(deletedAt)
-		e.CardType = nullToCardType(cardType)
-		e.CardData = nullToPtr(cardData)
-		e.LastUsedAt = parseTimePtr(lastUsedAt)
-
 		entities = append(entities, e)
 	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
 
 	if err := s.batchLoadTags(entities); err != nil {
 		return nil, err
@@ -308,6 +319,14 @@ func (s *Store) Update(id string, u *EntityUpdate) error {
 		sets = append(sets, "body = ?")
 		args = append(args, *u.Body)
 	}
+	if u.Title != nil {
+		sets = append(sets, "title = ?")
+		args = append(args, *u.Title)
+	}
+	if u.Description != nil {
+		sets = append(sets, "description = ?")
+		args = append(args, *u.Description)
+	}
 	if u.Glyph != nil {
 		sets = append(sets, "glyph = ?")
 		args = append(args, string(*u.Glyph))
@@ -318,6 +337,12 @@ func (s *Store) Update(id string, u *EntityUpdate) error {
 		sets = append(sets, "time_anchor = ?")
 		args = append(args, *u.TimeAnchor)
 	}
+	if u.ClearCompleted {
+		sets = append(sets, "completed_at = NULL")
+	} else if u.CompletedAt != nil {
+		sets = append(sets, "completed_at = ?")
+		args = append(args, u.CompletedAt.Format(time.RFC3339))
+	}
 	if u.Pinned != nil {
 		sets = append(sets, "pinned = ?")
 		args = append(args, boolToInt(*u.Pinned))
@@ -327,6 +352,9 @@ func (s *Store) Update(id string, u *EntityUpdate) error {
 		args = append(args, string(*u.CardType))
 	}
 	if u.CardData != nil {
+		if !json.Valid([]byte(*u.CardData)) {
+			return ErrInvalidCardData
+		}
 		sets = append(sets, "card_data = ?")
 		args = append(args, *u.CardData)
 	}
@@ -361,6 +389,9 @@ func (s *Store) Promote(id string, cardType CardType, cardData *string) error {
 
 	dataVal := "{}"
 	if cardData != nil {
+		if !json.Valid([]byte(*cardData)) {
+			return ErrInvalidCardData
+		}
 		dataVal = *cardData
 	}
 
@@ -464,8 +495,9 @@ func (s *Store) Absorb(targetID, sourceID string) error {
 		}
 	}
 
-	if _, err := tx.Exec("UPDATE entities SET deleted_at = ? WHERE id = ?",
+	absorbNote := source.Body + "\n\n[absorbed into " + targetID + "]"
-		now, sourceID); err != nil {
+	if _, err := tx.Exec("UPDATE entities SET body = ?, deleted_at = ?, modified_at = ? WHERE id = ?",
+		absorbNote, now, now, sourceID); err != nil {
 		return err
 	}
 
@@ -502,6 +534,9 @@ func (s *Store) Resolve(prefix string) (string, error) {
 		}
 		ids = append(ids, id)
 	}
+	if err := rows.Err(); err != nil {
+		return "", err
+	}
 
 	switch len(ids) {
 	case 0:
@@ -513,6 +548,44 @@ func (s *Store) Resolve(prefix string) (string, error) {
 	}
 }
 
+type entityRow struct {
+	createdAt, modifiedAt              string
+	completedAt, deletedAt, lastUsedAt sql.NullString
+	timeAnchor, cardType, cardData     sql.NullString
+	title, description                 sql.NullString
+	pinned                             int
+}
+
+func newEntityRow() *entityRow { return &entityRow{} }
+
+func (r *entityRow) ptrs(e *Entity) []any {
+	return []any{
+		&e.ID, &r.createdAt, &r.modifiedAt, &e.Body, &r.title, &r.description,
+		&e.Glyph, &r.timeAnchor, &r.completedAt, &r.pinned, &r.deletedAt,
+		&r.cardType, &r.cardData, &e.UseCount, &r.lastUsedAt,
+	}
+}
+
+func (r *entityRow) apply(e *Entity) error {
+	var err error
+	if e.CreatedAt, err = time.Parse(time.RFC3339, r.createdAt); err != nil {
+		return fmt.Errorf("created_at: %w", err)
+	}
+	if e.ModifiedAt, err = time.Parse(time.RFC3339, r.modifiedAt); err != nil {
+		return fmt.Errorf("modified_at: %w", err)
+	}
+	e.Title = nullToPtr(r.title)
+	e.Description = nullToPtr(r.description)
+	e.TimeAnchor = nullToPtr(r.timeAnchor)
+	e.CompletedAt = parseTimePtr(r.completedAt)
+	e.Pinned = r.pinned != 0
+	e.DeletedAt = parseTimePtr(r.deletedAt)
+	e.CardType = nullToCardType(r.cardType)
+	e.CardData = nullToPtr(r.cardData)
+	e.LastUsedAt = parseTimePtr(r.lastUsedAt)
+	return nil
+}
+
 // helpers
 
 func (s *Store) batchLoadTags(entities []*Entity) error {
@@ -568,6 +641,9 @@ func (s *Store) loadTags(entityID string) ([]string, error) {
 		}
 		tags = append(tags, tag)
 	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
 	if tags == nil {
 		tags = []string{}
 	}
@@ -631,11 +707,13 @@ func boolToInt(b bool) int {
 	return 0
 }
 
-func (e *Entity) CardDataJSON() map[string]interface{} {
+func (e *Entity) CardDataJSON() (map[string]interface{}, error) {
 	if e.CardData == nil {
-		return nil
+		return nil, nil
 	}
 	var m map[string]interface{}
-	json.Unmarshal([]byte(*e.CardData), &m)
+	if err := json.Unmarshal([]byte(*e.CardData), &m); err != nil {
-	return m
+		return nil, fmt.Errorf("card_data: %w", err)
+	}
+	return m, nil
 }

internal/db/entities_test.go

@@ -441,3 +441,130 @@ func TestResolve_NotFound(t *testing.T) {
 		t.Errorf("expected ErrNotFound, got %v", err)
 	}
 }
+
+func TestAbsorb_SourceIsCard(t *testing.T) {
+	s := testStore(t)
+	target := &Entity{Body: "target", Glyph: GlyphNote, Tags: []string{"a"}}
+	s.Create(target)
+
+	source := &Entity{Body: "source", Glyph: GlyphNote}
+	s.Create(source)
+	s.Promote(source.ID, CardSnippet, nil)
+	s.IncrementUse(source.ID)
+
+	if err := s.Absorb(target.ID, source.ID); err != nil {
+		t.Fatal(err)
+	}
+
+	got, _ := s.Get(target.ID)
+	if got.Body != "target\nsource" {
+		t.Errorf("merged body: %q", got.Body)
+	}
+
+	src, _ := s.Get(source.ID)
+	if src.CardType != nil {
+		t.Error("source card_type should be cleared after absorb")
+	}
+	if src.UseCount != 0 {
+		t.Errorf("source use_count should be reset, got %d", src.UseCount)
+	}
+	if src.DeletedAt == nil {
+		t.Error("source should be soft-deleted")
+	}
+}
+
+func TestCreate_WithTitleAndDescription(t *testing.T) {
+	s := testStore(t)
+	e := &Entity{
+		Body:        "body text",
+		Title:       ptr("nginx trick"),
+		Description: ptr("always forget this"),
+		Glyph:       GlyphNote,
+		Tags:        []string{"ops"},
+	}
+	if err := s.Create(e); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := s.Get(e.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.Title == nil || *got.Title != "nginx trick" {
+		t.Errorf("title: got %v", got.Title)
+	}
+	if got.Description == nil || *got.Description != "always forget this" {
+		t.Errorf("description: got %v", got.Description)
+	}
+	if got.Body != "body text" {
+		t.Errorf("body: got %q", got.Body)
+	}
+}
+
+func TestCreate_WithoutTitle(t *testing.T) {
+	s := testStore(t)
+	e := &Entity{Body: "just body", Glyph: GlyphNote}
+	if err := s.Create(e); err != nil {
+		t.Fatal(err)
+	}
+
+	got, _ := s.Get(e.ID)
+	if got.Title != nil {
+		t.Errorf("expected nil title, got %v", got.Title)
+	}
+	if got.Description != nil {
+		t.Errorf("expected nil description, got %v", got.Description)
+	}
+}
+
+func TestUpdate_Title(t *testing.T) {
+	s := testStore(t)
+	e := &Entity{Body: "body", Glyph: GlyphNote}
+	s.Create(e)
+
+	newTitle := "new title"
+	if err := s.Update(e.ID, &EntityUpdate{Title: &newTitle}); err != nil {
+		t.Fatal(err)
+	}
+
+	got, _ := s.Get(e.ID)
+	if got.Title == nil || *got.Title != "new title" {
+		t.Errorf("title: got %v", got.Title)
+	}
+}
+
+func TestUpdate_Description(t *testing.T) {
+	s := testStore(t)
+	e := &Entity{Body: "body", Glyph: GlyphNote}
+	s.Create(e)
+
+	newDesc := "new desc"
+	if err := s.Update(e.ID, &EntityUpdate{Description: &newDesc}); err != nil {
+		t.Fatal(err)
+	}
+
+	got, _ := s.Get(e.ID)
+	if got.Description == nil || *got.Description != "new desc" {
+		t.Errorf("description: got %v", got.Description)
+	}
+}
+
+func TestAbsorb_PreservesTargetTitle(t *testing.T) {
+	s := testStore(t)
+	target := &Entity{Body: "target body", Title: ptr("target title"), Glyph: GlyphNote}
+	source := &Entity{Body: "source body", Title: ptr("source title"), Glyph: GlyphNote}
+	s.Create(target)
+	s.Create(source)
+
+	if err := s.Absorb(target.ID, source.ID); err != nil {
+		t.Fatal(err)
+	}
+
+	got, _ := s.Get(target.ID)
+	if got.Title == nil || *got.Title != "target title" {
+		t.Errorf("target title should be preserved, got %v", got.Title)
+	}
+	if got.Body != "target body\nsource body" {
+		t.Errorf("body: got %q", got.Body)
+	}
+}

internal/db/tags.go

@@ -5,12 +5,16 @@ type TagCount struct {
 	Count int
 }
 
-func (s *Store) ListTags() ([]TagCount, error) {
+func (s *Store) ListTags(cardsOnly bool) ([]TagCount, error) {
+	where := "WHERE e.deleted_at IS NULL"
+	if cardsOnly {
+		where += " AND e.card_type IS NOT NULL"
+	}
 	rows, err := s.db.Query(`
 		SELECT t.tag, COUNT(*) as cnt
 		FROM entity_tags t
 		JOIN entities e ON t.entity_id = e.id
-		WHERE e.deleted_at IS NULL
+		` + where + `
 		GROUP BY t.tag
 		ORDER BY t.tag`)
 	if err != nil {
@@ -26,6 +30,9 @@ func (s *Store) ListTags() ([]TagCount, error) {
 		}
 		tags = append(tags, tc)
 	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
 	if tags == nil {
 		tags = []TagCount{}
 	}

internal/db/tags_test.go

@@ -4,7 +4,7 @@ import "testing"
 
 func TestListTags_Empty(t *testing.T) {
 	s := testStore(t)
-	tags, err := s.ListTags()
+	tags, err := s.ListTags(false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -19,7 +19,7 @@ func TestListTags_Counts(t *testing.T) {
 	s.Create(&Entity{Body: "b", Glyph: GlyphNote, Tags: []string{"ops"}})
 	s.Create(&Entity{Body: "c", Glyph: GlyphNote, Tags: []string{"home"}})
 
-	tags, err := s.ListTags()
+	tags, err := s.ListTags(false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -50,7 +50,7 @@ func TestListTags_ExcludesDeleted(t *testing.T) {
 
 	s.Create(&Entity{Body: "alive", Glyph: GlyphNote, Tags: []string{"here"}})
 
-	tags, err := s.ListTags()
+	tags, err := s.ListTags(false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -61,3 +61,37 @@ func TestListTags_ExcludesDeleted(t *testing.T) {
 		t.Errorf("expected 'here', got %q", tags[0].Tag)
 	}
 }
+
+func TestListTags_CardsOnly(t *testing.T) {
+	s := testStore(t)
+	s.Create(&Entity{Body: "fluid", Glyph: GlyphNote, Tags: []string{"ops", "shared"}})
+
+	ct := CardSnippet
+	s.Create(&Entity{Body: "card", Glyph: GlyphNote, Tags: []string{"ops", "code"}, CardType: &ct})
+
+	all, err := s.ListTags(false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(all) != 3 {
+		t.Fatalf("all tags: expected 3, got %d", len(all))
+	}
+
+	cards, err := s.ListTags(true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(cards) != 2 {
+		t.Fatalf("card tags: expected 2, got %d", len(cards))
+	}
+	counts := map[string]int{}
+	for _, tc := range cards {
+		counts[tc.Tag] = tc.Count
+	}
+	if counts["ops"] != 1 {
+		t.Errorf("ops count: expected 1 (card only), got %d", counts["ops"])
+	}
+	if counts["code"] != 1 {
+		t.Errorf("code count: expected 1, got %d", counts["code"])
+	}
+}

internal/display/glyph.go

@@ -3,9 +3,10 @@ package display
 import "github.com/lerko/nib/internal/db"
 
 var glyphMap = map[db.Glyph]string{
-	db.GlyphNote:  "◦",
+	db.GlyphNote:     "—",
-	db.GlyphTodo:  "▸",
+	db.GlyphTodo:     "○",
 	db.GlyphEvent:    "◇",
+	db.GlyphReminder: "△",
 }
 
 var cardGlyphMap = map[db.CardType]string{
@@ -14,6 +15,7 @@ var cardGlyphMap = map[db.CardType]string{
 	db.CardChecklist: "☐",
 	db.CardDecision:  "⚖",
 	db.CardLink:      "↗",
+	db.CardNote:      "¶",
 }
 
 func DisplayGlyph(glyph db.Glyph, cardType *db.CardType) string {
@@ -25,7 +27,7 @@ func DisplayGlyph(glyph db.Glyph, cardType *db.CardType) string {
 	if g, ok := glyphMap[glyph]; ok {
 		return g
 	}
-	return "◦"
+	return "—"
 }
 
 func FormatID(id string) string {

internal/display/glyph_test.go

@@ -0,0 +1,80 @@
+package display
+
+import (
+	"testing"
+
+	"github.com/lerko/nib/internal/db"
+)
+
+func TestDisplayGlyph_Fluid(t *testing.T) {
+	tests := []struct {
+		glyph db.Glyph
+		want  string
+	}{
+		{db.GlyphNote, "—"},
+		{db.GlyphTodo, "○"},
+		{db.GlyphEvent, "◇"},
+	}
+	for _, tt := range tests {
+		got := DisplayGlyph(tt.glyph, nil)
+		if got != tt.want {
+			t.Errorf("DisplayGlyph(%q, nil) = %q, want %q", tt.glyph, got, tt.want)
+		}
+	}
+}
+
+func TestDisplayGlyph_Card(t *testing.T) {
+	tests := []struct {
+		cardType db.CardType
+		want     string
+	}{
+		{db.CardSnippet, "◆"},
+		{db.CardTemplate, "◈"},
+		{db.CardChecklist, "☐"},
+		{db.CardDecision, "⚖"},
+		{db.CardLink, "↗"},
+	}
+	for _, tt := range tests {
+		ct := tt.cardType
+		got := DisplayGlyph(db.GlyphNote, &ct)
+		if got != tt.want {
+			t.Errorf("DisplayGlyph(note, %q) = %q, want %q", tt.cardType, got, tt.want)
+		}
+	}
+}
+
+func TestDisplayGlyph_CardOverridesGlyph(t *testing.T) {
+	ct := db.CardSnippet
+	got := DisplayGlyph(db.GlyphTodo, &ct)
+	if got != "◆" {
+		t.Errorf("card_type should override glyph, got %q", got)
+	}
+}
+
+func TestDisplayGlyph_UnknownFallback(t *testing.T) {
+	got := DisplayGlyph(db.Glyph("unknown"), nil)
+	if got != "—" {
+		t.Errorf("unknown glyph should fall back to —, got %q", got)
+	}
+}
+
+func TestFormatID_Long(t *testing.T) {
+	got := FormatID("01HXYZ1234567890ABCDEFGH")
+	if got != "01HXYZ123456" {
+		t.Errorf("expected 12-char truncation, got %q", got)
+	}
+}
+
+func TestFormatID_Short(t *testing.T) {
+	got := FormatID("ABC")
+	if got != "ABC" {
+		t.Errorf("short ID should pass through, got %q", got)
+	}
+}
+
+func TestFormatID_Exact12(t *testing.T) {
+	got := FormatID("123456789012")
+	if got != "123456789012" {
+		t.Errorf("exact 12-char should pass through, got %q", got)
+	}
+}

internal/parse/grammar.go

@@ -9,9 +9,14 @@ import (
 type Result struct {
 	Body        string
 	Glyph       string
+	Title       *string
+	Description *string
 	TimeAnchor  *string
 	Tags        []string
+	FilterTags  []string
 	CardSuffix  *string
+	Pin         bool
+	Query       bool
 }
 
 var validCardTypes = map[string]string{
@@ -22,6 +27,8 @@ var validCardTypes = map[string]string{
 	"checklist": "checklist",
 	"decision":  "decision",
 	"link":      "link",
+	"note":      "note",
+	"n":         "note",
 }
 
 func Parse(input string) (*Result, error) {
@@ -35,38 +42,207 @@ func Parse(input string) (*Result, error) {
 		Tags:  []string{},
 	}
 
-	tokens := strings.Fields(input)
+	remaining := input
-	if len(tokens) == 0 {
+
-		return nil, fmt.Errorf("empty input")
+	// Step 1: Escape check — `\` prefix → thought, no prefix detection
-	}
+	if strings.HasPrefix(remaining, `\`) {
-
+		remaining = remaining[1:]
-	first := tokens[0]
+		r.Glyph = "note"
-	switch first {
+		clean, err := extractModifiers(r, remaining, false)
-	case "-", "▸":
+		if err != nil {
-		r.Glyph = "todo"
+			return nil, err
-		tokens = tokens[1:]
+		}
-	case "*", "◇":
+		r.Body = clean
-		r.Glyph = "event"
+		if r.Body == "" && r.Title == nil {
-		tokens = tokens[1:]
+			return nil, fmt.Errorf("empty body after extracting modifiers")
+		}
+		return r, nil
 	}
 
+	// Step 2: Query check — `?` prefix → search mode
+	if strings.HasPrefix(remaining, "?") {
+		remaining = strings.TrimSpace(remaining[1:])
+		r.Query = true
+		r.Glyph = ""
+		tokens := strings.Fields(remaining)
 		var bodyParts []string
-	seen := map[string]bool{}
-
 		for _, tok := range tokens {
-		switch {
+			if strings.HasPrefix(tok, "#") && len(tok) > 1 && !strings.HasPrefix(tok, "##") {
-		case strings.HasPrefix(tok, "@") && len(tok) > 1:
+				tag := strings.ToLower(tok[1:])
-			timeStr := tok[1:]
+				r.FilterTags = append(r.FilterTags, tag)
-			if err := validateTime(timeStr); err != nil {
+			} else {
-				return nil, fmt.Errorf("invalid time %q: %w", timeStr, err)
+				bodyParts = append(bodyParts, tok)
 			}
-			if r.TimeAnchor != nil {
+		}
-				return nil, fmt.Errorf("multiple time anchors")
+		r.Body = strings.Join(bodyParts, " ")
+		return r, nil
+	}
+
+	// Step 3: Kind prefix — `-`, `@time`, `!time`
+	// `@` and `!` are kind prefixes ONLY if followed by a valid time token.
+	// Otherwise the input is treated as a plain note.
+	if strings.HasPrefix(remaining, "- ") {
+		r.Glyph = "todo"
+		remaining = strings.TrimSpace(remaining[2:])
+	} else if remaining == "-" {
+		r.Glyph = "todo"
+		remaining = ""
+	} else if strings.HasPrefix(remaining, "@") {
+		if rest, ok := tryPrefixTime(r, remaining[1:]); ok {
+			r.Glyph = "event"
+			remaining = rest
+		}
+	} else if strings.HasPrefix(remaining, "!") {
+		afterBang := remaining[1:]
+		// `!pin` is a flag, not a reminder prefix
+		firstWord := ""
+		if fields := strings.Fields(afterBang); len(fields) > 0 {
+			firstWord = fields[0]
+		}
+		if !strings.EqualFold(firstWord, "pin") {
+			if rest, ok := tryPrefixTime(r, afterBang); ok {
+				r.Glyph = "reminder"
+				remaining = rest
+			}
+		}
+	}
+
+	// Steps 4-5: Title and description extraction
+	var titleRaw, descRaw string
+	hasTitle := false
+
+	lines := strings.SplitN(remaining, "\n", 2)
+	firstLine := strings.TrimSpace(lines[0])
+
+	if strings.HasPrefix(firstLine, "|") {
+		hasTitle = true
+		titleContent := firstLine[1:]
+		if idx := strings.Index(titleContent, " // "); idx >= 0 {
+			titleRaw = strings.TrimSpace(titleContent[:idx])
+			descRaw = strings.TrimSpace(titleContent[idx+4:])
+		} else {
+			titleRaw = strings.TrimSpace(titleContent)
+		}
+		if len(lines) > 1 {
+			remaining = lines[1]
+		} else {
+			remaining = ""
+		}
+	} else {
+		allLines := strings.Split(remaining, "\n")
+		var descParts []string
+		startBody := 0
+		for i, line := range allLines {
+			trimmed := strings.TrimSpace(line)
+			if strings.HasPrefix(trimmed, "// ") || trimmed == "//" {
+				descParts = append(descParts, strings.TrimSpace(trimmed[2:]))
+				startBody = i + 1
+			} else {
+				break
+			}
+		}
+		if len(descParts) > 0 {
+			descRaw = strings.Join(descParts, " ")
+			remaining = strings.Join(allLines[startBody:], "\n")
+		} else if !strings.Contains(firstLine, "://") {
+			if idx := strings.Index(firstLine, " // "); idx >= 0 {
+				descRaw = strings.TrimSpace(firstLine[idx+4:])
+				remaining = strings.TrimSpace(firstLine[:idx])
+				if len(lines) > 1 {
+					remaining += "\n" + lines[1]
+				}
+			}
+		}
+	}
+
+	// Steps 6-8: Extract flags, tags, time, card suffix from title/desc/body
+	if hasTitle {
+		clean, err := extractModifiers(r, titleRaw, false)
+		if err != nil {
+			return nil, err
+		}
+		if clean != "" {
+			r.Title = &clean
+		}
+	}
+	if descRaw != "" {
+		clean, err := extractModifiers(r, descRaw, false)
+		if err != nil {
+			return nil, err
+		}
+		if clean != "" {
+			r.Description = &clean
+		}
+	}
+
+	clean, err := extractModifiers(r, remaining, true)
+	if err != nil {
+		return nil, err
+	}
+	r.Body = clean
+
+	if r.Body == "" && r.Title == nil {
+		return nil, fmt.Errorf("empty body after extracting modifiers")
+	}
+
+	return r, nil
+}
+
+// tryPrefixTime attempts to extract a time token from the start of text.
+// Returns (remaining text, true) on success, or ("", false) if no valid time found.
+func tryPrefixTime(r *Result, text string) (string, bool) {
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return "", false
+	}
+	sp := strings.IndexByte(text, ' ')
+	var timeStr, rest string
+	if sp >= 0 {
+		timeStr = text[:sp]
+		rest = strings.TrimSpace(text[sp+1:])
+	} else {
+		timeStr = text
+		rest = ""
+	}
+	if validateTime(timeStr) != nil {
+		return "", false
 	}
 	r.TimeAnchor = &timeStr
+	return rest, true
+}
+
+// extractModifiers extracts tags, flags, time anchors, and card suffixes from text.
+// handleFlags controls whether !pin is extracted (true for body, false for title/desc in some contexts).
+func extractModifiers(r *Result, text string, handleFlags bool) (string, error) {
+	seen := map[string]bool{}
+	for _, t := range r.Tags {
+		seen[strings.ToLower(t)] = true
+	}
+
+	var outLines []string
+	for _, line := range strings.Split(text, "\n") {
+		tokens := strings.Fields(line)
+		var lineParts []string
+		for _, tok := range tokens {
+			switch {
+			case handleFlags && strings.EqualFold(tok, "!pin"):
+				r.Pin = true
+
+			case strings.HasPrefix(tok, "##") && len(tok) > 2:
+				lineParts = append(lineParts, "#"+tok[2:])
+
+			case strings.HasPrefix(tok, "@") && len(tok) > 1:
+				timeStr := tok[1:]
+				if validateTime(timeStr) != nil {
+					lineParts = append(lineParts, tok)
+				} else if r.TimeAnchor != nil {
+					return "", fmt.Errorf("multiple time anchors")
+				} else {
+					r.TimeAnchor = &timeStr
+				}
 
 			case strings.HasPrefix(tok, "#") && len(tok) > 1:
-			tag := tok[1:]
+				tag := strings.ToLower(tok[1:])
 				if !seen[tag] {
 					r.Tags = append(r.Tags, tag)
 					seen[tag] = true
@@ -76,24 +252,20 @@ func Parse(input string) (*Result, error) {
 				suffix := tok[1:]
 				cardType, ok := validCardTypes[suffix]
 				if !ok {
-				return nil, fmt.Errorf("invalid card type %q", suffix)
+					return "", fmt.Errorf("invalid card type %q", suffix)
 				}
 				if r.CardSuffix != nil {
-				return nil, fmt.Errorf("multiple card suffixes")
+					return "", fmt.Errorf("multiple card suffixes")
 				}
 				r.CardSuffix = &cardType
 
 			default:
-			bodyParts = append(bodyParts, tok)
+				lineParts = append(lineParts, tok)
 			}
 		}
-
+		outLines = append(outLines, strings.Join(lineParts, " "))
-	r.Body = strings.Join(bodyParts, " ")
-	if r.Body == "" {
-		return nil, fmt.Errorf("empty body after extracting modifiers")
 	}
-
+	return strings.Join(outLines, "\n"), nil
-	return r, nil
 }
 
 func validateTime(s string) error {

internal/parse/grammar_test.go

@@ -13,46 +13,97 @@ func TestParse(t *testing.T) {
 		input      string
 		wantBody   string
 		wantGlyph  string
+		wantTitle  *string
+		wantDesc   *string
 		wantTime   *string
 		wantTags   []string
 		wantCard   *string
+		wantPin    bool
+		wantQuery  bool
+		wantFilter []string
 		wantErrSub string
 	}{
-		// Glyph detection
+		// Kind prefixes
-		{"plain note", "hello world", "hello world", "note", nil, nil, nil, ""},
+		{"plain note", "hello world", "hello world", "note", nil, nil, nil, nil, nil, false, false, nil, ""},
-		{"dash todo", "- deploy nginx", "deploy nginx", "todo", nil, nil, nil, ""},
+		{"dash todo", "- deploy nginx", "deploy nginx", "todo", nil, nil, nil, nil, nil, false, false, nil, ""},
-		{"unicode todo", "▸ deploy nginx", "deploy nginx", "todo", nil, nil, nil, ""},
+		{"dash todo requires space", "-deploy", "-deploy", "note", nil, nil, nil, nil, nil, false, false, nil, ""},
-		{"star event", "* dentist", "dentist", "event", nil, nil, nil, ""},
+		{"event prefix", "@14:00 dentist", "dentist", "event", nil, nil, sp("14:00"), nil, nil, false, false, nil, ""},
-		{"unicode event", "◇ dentist", "dentist", "event", nil, nil, nil, ""},
+		{"event no body", "@9:30", "", "event", nil, nil, sp("9:30"), nil, nil, false, false, nil, "empty body"},
+		{"reminder prefix", "!15:00 call dentist", "call dentist", "reminder", nil, nil, sp("15:00"), nil, nil, false, false, nil, ""},
+		{"reminder no body", "!9:30", "", "reminder", nil, nil, sp("9:30"), nil, nil, false, false, nil, "empty body"},
 
-		// Time anchor
+		// Event/reminder with invalid time — @ stays as body token, ! stays as body token
-		{"with time", "meeting @14:00", "meeting", "note", sp("14:00"), nil, nil, ""},
+		{"at-sign not time", "@nottime hello", "@nottime hello", "note", nil, nil, nil, nil, nil, false, false, nil, ""},
-		{"time at start", "@9:30 standup", "standup", "note", sp("9:30"), nil, nil, ""},
+		{"bang not time", "!nottime hello", "!nottime hello", "note", nil, nil, nil, nil, nil, false, false, nil, ""},
-		{"invalid hours", "meeting @25:00", "", "", nil, nil, nil, "invalid time"},
-		{"invalid minutes", "meeting @14:60", "", "", nil, nil, nil, "invalid time"},
 
-		// Tags
+		// Escape prefix
-		{"single tag", "deploy #ops", "deploy", "note", nil, []string{"ops"}, nil, ""},
+		{"escape dash", `\- this is not a todo`, "- this is not a todo", "note", nil, nil, nil, nil, nil, false, false, nil, ""},
-		{"multiple tags", "deploy #ops #infra", "deploy", "note", nil, []string{"ops", "infra"}, nil, ""},
+		{"escape at", `\@14:00 not event`, "not event", "note", nil, nil, sp("14:00"), nil, nil, false, false, nil, ""},
-		{"duplicate tags", "deploy #ops #ops", "deploy", "note", nil, []string{"ops"}, nil, ""},
+		{"escape plain", `\hello`, "hello", "note", nil, nil, nil, nil, nil, false, false, nil, ""},
-		{"tag with hyphen", "task #dev-ops", "task", "note", nil, []string{"dev-ops"}, nil, ""},
 
-		// Card suffix
+		// Query mode
-		{"caret card", "trick #nginx ^card", "trick", "note", nil, []string{"nginx"}, sp("snippet"), ""},
+		{"query basic", "? proxy config", "proxy config", "", nil, nil, nil, nil, nil, false, true, nil, ""},
-		{"caret c", "trick ^c", "trick", "note", nil, nil, sp("snippet"), ""},
+		{"query with tags", "? proxy config #ops #infra", "proxy config", "", nil, nil, nil, nil, nil, false, true, []string{"ops", "infra"}, ""},
-		{"caret template", "deploy ${host} ^template", "deploy ${host}", "note", nil, nil, sp("template"), ""},
+		{"query tags only", "? #ops", "", "", nil, nil, nil, nil, nil, false, true, []string{"ops"}, ""},
-		{"caret snippet explicit", "trick ^snippet", "trick", "note", nil, nil, sp("snippet"), ""},
+
-		{"invalid card type", "thing ^bogus", "", "", nil, nil, nil, "invalid card type"},
+		// Inline time anchor
+		{"inline time", "meeting @14:00", "meeting", "note", nil, nil, sp("14:00"), nil, nil, false, false, nil, ""},
+		{"todo due time", "- buy milk @9:30", "buy milk", "todo", nil, nil, sp("9:30"), nil, nil, false, false, nil, ""},
+		{"invalid hours stays as body", "meeting @25:00", "meeting @25:00", "note", nil, nil, nil, nil, nil, false, false, nil, ""},
+		{"invalid minutes stays as body", "meeting @14:60", "meeting @14:60", "note", nil, nil, nil, nil, nil, false, false, nil, ""},
+
+		// Tags (lowercased)
+		{"single tag", "deploy #Ops", "deploy", "note", nil, nil, nil, []string{"ops"}, nil, false, false, nil, ""},
+		{"multiple tags", "deploy #ops #Infra", "deploy", "note", nil, nil, nil, []string{"ops", "infra"}, nil, false, false, nil, ""},
+		{"duplicate tags", "deploy #ops #Ops", "deploy", "note", nil, nil, nil, []string{"ops"}, nil, false, false, nil, ""},
+		{"tag with hyphen", "task #dev-ops", "task", "note", nil, nil, nil, []string{"dev-ops"}, nil, false, false, nil, ""},
+
+		// Hash escape
+		{"double hash escape", "use ##channel in slack", "use #channel in slack", "note", nil, nil, nil, nil, nil, false, false, nil, ""},
+		{"double hash with tag", "use ##channel #ops", "use #channel", "note", nil, nil, nil, []string{"ops"}, nil, false, false, nil, ""},
+
+		// Pin flag
+		{"pin flag", "important thing !pin", "important thing", "note", nil, nil, nil, nil, nil, true, false, nil, ""},
+		{"pin case insensitive", "important !Pin #work", "important", "note", nil, nil, nil, []string{"work"}, nil, true, false, nil, ""},
+		{"pin with todo", "- urgent task !pin", "urgent task", "todo", nil, nil, nil, nil, nil, true, false, nil, ""},
+
+		// !pin at start — not a reminder, flag is extracted
+		{"bang pin only", "!pin important", "important", "note", nil, nil, nil, nil, nil, true, false, nil, ""},
+
+		// Card suffix (kept for now)
+		{"caret card", "trick #nginx ^card", "trick", "note", nil, nil, nil, []string{"nginx"}, sp("snippet"), false, false, nil, ""},
+		{"caret c", "trick ^c", "trick", "note", nil, nil, nil, nil, sp("snippet"), false, false, nil, ""},
+		{"caret template", "deploy ${host} ^template", "deploy ${host}", "note", nil, nil, nil, nil, sp("template"), false, false, nil, ""},
+		{"invalid card type", "thing ^bogus", "", "", nil, nil, nil, nil, nil, false, false, nil, "invalid card type"},
 
 		// Combined
-		{"full input", "- deploy nginx to staging @15:00 #ops", "deploy nginx to staging", "todo", sp("15:00"), []string{"ops"}, nil, ""},
+		{"full todo", "- deploy nginx @15:00 #ops", "deploy nginx", "todo", nil, nil, sp("15:00"), []string{"ops"}, nil, false, false, nil, ""},
-		{"full with card", "figured out the proxy_pass trick #nginx ^card", "figured out the proxy_pass trick", "note", nil, []string{"nginx"}, sp("snippet"), ""},
+		{"full event", "@14:00 lunch with alex #personal", "lunch with alex", "event", nil, nil, sp("14:00"), []string{"personal"}, nil, false, false, nil, ""},
+		{"full reminder", "!15:00 call dentist #health", "call dentist", "reminder", nil, nil, sp("15:00"), []string{"health"}, nil, false, false, nil, ""},
+
+		// Title
+		{"title with body", "|nginx trick\nproxy_pass trailing slash #ops", "proxy_pass trailing slash", "note", sp("nginx trick"), nil, nil, []string{"ops"}, nil, false, false, nil, ""},
+		{"no title", "no pipe here #ops", "no pipe here", "note", nil, nil, nil, []string{"ops"}, nil, false, false, nil, ""},
+		{"todo with title", "- |deploy staging\nrebuild docker #ops", "rebuild docker", "todo", sp("deploy staging"), nil, nil, []string{"ops"}, nil, false, false, nil, ""},
+		{"title only", "|title only", "", "note", sp("title only"), nil, nil, nil, nil, false, false, nil, ""},
+		{"title and desc", "|title // description #ops\nbody here", "body here", "note", sp("title"), sp("description"), nil, []string{"ops"}, nil, false, false, nil, ""},
+		{"todo title desc", "- |deploy staging // rebuild and push #ops", "", "todo", sp("deploy staging"), sp("rebuild and push"), nil, []string{"ops"}, nil, false, false, nil, ""},
+
+		// Description without title
+		{"leading desc", "// leading desc\nbody content", "body content", "note", nil, sp("leading desc"), nil, nil, nil, false, false, nil, ""},
+		{"inline desc", "body text // inline desc", "body text", "note", nil, sp("inline desc"), nil, nil, nil, false, false, nil, ""},
+		{"url no split", "http://example.com // should not split", "http://example.com // should not split", "note", nil, nil, nil, nil, nil, false, false, nil, ""},
+
+		// Multiline body preserves newlines
+		{"multiline body", "hello\nworld", "hello\nworld", "note", nil, nil, nil, nil, nil, false, false, nil, ""},
+		{"multiline with tags", "line one #ops\nline two", "line one\nline two", "note", nil, nil, nil, []string{"ops"}, nil, false, false, nil, ""},
+		{"title multiline body", "|my title\nfirst line\nsecond line", "first line\nsecond line", "note", sp("my title"), nil, nil, nil, nil, false, false, nil, ""},
 
 		// Edge cases
-		{"empty input", "", "", "", nil, nil, nil, "empty"},
+		{"empty input", "", "", "", nil, nil, nil, nil, nil, false, false, nil, "empty"},
-		{"only glyph", "-", "", "", nil, nil, nil, "empty body"},
+		{"only glyph", "-", "", "", nil, nil, nil, nil, nil, false, false, nil, "empty body"},
-		{"only modifiers", "#ops @14:00", "", "", nil, nil, nil, "empty body"},
+		{"only modifiers", "#ops @14:00", "", "", nil, nil, nil, nil, nil, false, false, nil, "empty body"},
-		{"whitespace only", "   ", "", "", nil, nil, nil, "empty"},
+		{"whitespace only", "   ", "", "", nil, nil, nil, nil, nil, false, false, nil, "empty"},
 	}
 
 	for _, tt := range tests {
@@ -79,6 +130,12 @@ func TestParse(t *testing.T) {
 			if got.Glyph != tt.wantGlyph {
 				t.Errorf("glyph: got %q, want %q", got.Glyph, tt.wantGlyph)
 			}
+			if !ptrEq(got.Title, tt.wantTitle) {
+				t.Errorf("title: got %v, want %v", strPtr(got.Title), strPtr(tt.wantTitle))
+			}
+			if !ptrEq(got.Description, tt.wantDesc) {
+				t.Errorf("description: got %v, want %v", strPtr(got.Description), strPtr(tt.wantDesc))
+			}
 			if !ptrEq(got.TimeAnchor, tt.wantTime) {
 				t.Errorf("time_anchor: got %v, want %v", strPtr(got.TimeAnchor), strPtr(tt.wantTime))
 			}
@@ -88,6 +145,15 @@ func TestParse(t *testing.T) {
 			if !ptrEq(got.CardSuffix, tt.wantCard) {
 				t.Errorf("card_suffix: got %v, want %v", strPtr(got.CardSuffix), strPtr(tt.wantCard))
 			}
+			if got.Pin != tt.wantPin {
+				t.Errorf("pin: got %v, want %v", got.Pin, tt.wantPin)
+			}
+			if got.Query != tt.wantQuery {
+				t.Errorf("query: got %v, want %v", got.Query, tt.wantQuery)
+			}
+			if !tagsEq(got.FilterTags, tt.wantFilter) {
+				t.Errorf("filter_tags: got %v, want %v", got.FilterTags, tt.wantFilter)
+			}
 		})
 	}
 }

internal/tui/absorb.go

@@ -0,0 +1,136 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/lerko/nib/internal/db"
+	"github.com/lerko/nib/internal/display"
+)
+
+type absorbModel struct {
+	targetID string
+	sources  []*db.Entity
+	cursor   int
+	offset   int
+	height   int
+}
+
+func newAbsorbModel(targetID string) absorbModel {
+	return absorbModel{targetID: targetID}
+}
+
+func (a *absorbModel) setSources(entities []*db.Entity) {
+	a.sources = nil
+	for _, e := range entities {
+		if e.ID != a.targetID {
+			a.sources = append(a.sources, e)
+		}
+	}
+	a.cursor = 0
+	a.offset = 0
+}
+
+func (a *absorbModel) setHeight(h int) {
+	a.height = h
+}
+
+func (a absorbModel) selectedSource() *db.Entity {
+	if len(a.sources) == 0 || a.cursor >= len(a.sources) {
+		return nil
+	}
+	return a.sources[a.cursor]
+}
+
+func (a absorbModel) update(msg tea.KeyMsg) absorbModel {
+	switch msg.String() {
+	case "up", "k":
+		if a.cursor > 0 {
+			a.cursor--
+			if a.cursor < a.offset {
+				a.offset = a.cursor
+			}
+		}
+	case "down", "j":
+		if a.cursor < len(a.sources)-1 {
+			a.cursor++
+			visible := a.visibleCount()
+			if a.cursor >= a.offset+visible {
+				a.offset = a.cursor - visible + 1
+			}
+		}
+	}
+	return a
+}
+
+func (a absorbModel) view(width int) string {
+	if len(a.sources) == 0 {
+		return statusStyle.Render("no other entities")
+	}
+
+	var b strings.Builder
+	b.WriteString(titleStyle.Render("absorb into " + display.FormatID(a.targetID)))
+	b.WriteString("\n")
+	b.WriteString(helpStyle.Render("select source to merge"))
+	b.WriteString("\n\n")
+
+	visible := a.visibleCount() - 4
+	if visible <= 0 {
+		visible = 10
+	}
+	end := min(a.offset+visible, len(a.sources))
+
+	for i := a.offset; i < end; i++ {
+		e := a.sources[i]
+		line := renderAbsorbSource(e, width-4)
+
+		if i == a.cursor {
+			b.WriteString(selectedItemStyle.Render(" " + line))
+		} else {
+			b.WriteString(listItemStyle.Render(line))
+		}
+		if i < end-1 {
+			b.WriteString("\n")
+		}
+	}
+
+	return b.String()
+}
+
+func (a absorbModel) visibleCount() int {
+	if a.height <= 0 {
+		return 20
+	}
+	return a.height
+}
+
+func renderAbsorbSource(e *db.Entity, maxWidth int) string {
+	glyph := glyphStyle.Render(display.DisplayGlyph(e.Glyph, e.CardType))
+	id := idStyle.Render("[" + display.FormatID(e.ID) + "]")
+
+	body := e.Body
+	if e.Title != nil {
+		body = *e.Title
+	}
+
+	var tags string
+	if len(e.Tags) > 0 {
+		limit := min(2, len(e.Tags))
+		tagParts := make([]string, limit)
+		for i := 0; i < limit; i++ {
+			tagParts[i] = tagStyle.Render("#" + e.Tags[i])
+		}
+		tags = " " + strings.Join(tagParts, " ")
+	}
+
+	line := fmt.Sprintf("%s %s%s %s", glyph, body, tags, id)
+
+	if maxWidth > 0 && len(stripAnsi(line)) > maxWidth {
+		body = truncate(body, maxWidth-20)
+		line = fmt.Sprintf("%s %s%s %s", glyph, body, tags, id)
+	}
+
+	return line
+}

internal/tui/cards.go

@@ -0,0 +1,262 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/lerko/nib/internal/db"
+	"github.com/lerko/nib/internal/display"
+)
+
+type intent int
+
+const (
+	intentAll intent = iota
+	intentGrab
+	intentRead
+	intentFill
+)
+
+func (i intent) String() string {
+	switch i {
+	case intentGrab:
+		return "grab"
+	case intentRead:
+		return "read"
+	case intentFill:
+		return "fill"
+	default:
+		return "all"
+	}
+}
+
+func (i intent) next() intent {
+	switch i {
+	case intentAll:
+		return intentGrab
+	case intentGrab:
+		return intentRead
+	case intentRead:
+		return intentFill
+	default:
+		return intentAll
+	}
+}
+
+func matchesIntent(e *db.Entity, i intent) bool {
+	if i == intentAll {
+		return true
+	}
+	ct := e.CardType
+	if ct == nil {
+		return i == intentGrab
+	}
+	switch i {
+	case intentGrab:
+		return *ct == db.CardSnippet
+	case intentRead:
+		return *ct == db.CardNote || *ct == db.CardLink || *ct == db.CardDecision
+	case intentFill:
+		return *ct == db.CardTemplate || *ct == db.CardChecklist
+	}
+	return false
+}
+
+type cardsModel struct {
+	entities []*db.Entity
+	filtered []*db.Entity
+	cursor   int
+	offset   int
+	height   int
+	width    int
+	intent   intent
+}
+
+func newCardsModel() cardsModel {
+	return cardsModel{}
+}
+
+func (c *cardsModel) setEntities(entities []*db.Entity) {
+	c.entities = entities
+	c.applyFilter()
+}
+
+func (c *cardsModel) setIntent(i intent) {
+	c.intent = i
+	c.cursor = 0
+	c.offset = 0
+	c.applyFilter()
+}
+
+func (c *cardsModel) applyFilter() {
+	c.filtered = nil
+	var pinned, rest []*db.Entity
+	for _, e := range c.entities {
+		if !matchesIntent(e, c.intent) {
+			continue
+		}
+		if e.Pinned {
+			pinned = append(pinned, e)
+		} else {
+			rest = append(rest, e)
+		}
+	}
+	c.filtered = append(pinned, rest...)
+	if c.cursor >= len(c.filtered) {
+		c.cursor = max(0, len(c.filtered)-1)
+	}
+}
+
+func (c *cardsModel) setSize(width, height int) {
+	c.width = width
+	c.height = height
+}
+
+func (c cardsModel) selected() *db.Entity {
+	if len(c.filtered) == 0 || c.cursor >= len(c.filtered) {
+		return nil
+	}
+	return c.filtered[c.cursor]
+}
+
+func (c cardsModel) update(msg tea.KeyMsg) cardsModel {
+	switch msg.String() {
+	case "up", "k":
+		if c.cursor > 0 {
+			c.cursor--
+			if c.cursor < c.offset {
+				c.offset = c.cursor
+			}
+		}
+	case "down", "j":
+		if c.cursor < len(c.filtered)-1 {
+			c.cursor++
+			visible := c.visibleCount()
+			if c.cursor >= c.offset+visible {
+				c.offset = c.cursor - visible + 1
+			}
+		}
+	case "home", "g":
+		c.cursor = 0
+		c.offset = 0
+	case "end", "G":
+		c.cursor = max(0, len(c.filtered)-1)
+		visible := c.visibleCount()
+		if c.cursor >= visible {
+			c.offset = c.cursor - visible + 1
+		}
+	case "pgup", "ctrl+u":
+		c.cursor = max(0, c.cursor-c.visibleCount())
+		if c.cursor < c.offset {
+			c.offset = c.cursor
+		}
+	case "pgdown", "ctrl+d":
+		c.cursor = min(len(c.filtered)-1, c.cursor+c.visibleCount())
+		visible := c.visibleCount()
+		if c.cursor >= c.offset+visible {
+			c.offset = c.cursor - visible + 1
+		}
+	}
+	return c
+}
+
+func (c cardsModel) view(width int) string {
+	if len(c.filtered) == 0 {
+		return statusStyle.Render("no cards")
+	}
+
+	var b strings.Builder
+	visible := c.visibleCount()
+	end := min(c.offset+visible, len(c.filtered))
+
+	for i := c.offset; i < end; i++ {
+		e := c.filtered[i]
+		line := renderCard(e, width-4)
+
+		if i == c.cursor {
+			b.WriteString(selectedItemStyle.Render(" " + line))
+		} else {
+			b.WriteString(listItemStyle.Render(line))
+		}
+		if i < end-1 {
+			b.WriteString("\n")
+		}
+	}
+
+	return b.String()
+}
+
+func (c cardsModel) visibleCount() int {
+	if c.height <= 0 {
+		return 20
+	}
+	return c.height
+}
+
+func renderCard(e *db.Entity, maxWidth int) string {
+	glyph := glyphStyle.Render(display.DisplayGlyph(e.Glyph, e.CardType))
+	id := idStyle.Render("[" + display.FormatID(e.ID) + "]")
+
+	body := e.Body
+	if e.Title != nil {
+		body = *e.Title
+	}
+
+	affordance := detectAffordance(e)
+	affordStr := ""
+	if affordance != "" {
+		affordStr = " " + affordanceStyle.Render(affordance)
+	}
+
+	var extras []string
+	if e.Pinned {
+		extras = append(extras, pinnedStyle.Render("•"))
+	}
+	if len(e.Tags) > 0 {
+		limit := min(2, len(e.Tags))
+		for _, t := range e.Tags[:limit] {
+			extras = append(extras, tagStyle.Render("#"+t))
+		}
+	}
+
+	extraStr := ""
+	if len(extras) > 0 {
+		extraStr = " " + strings.Join(extras, " ")
+	}
+
+	useStr := ""
+	if e.UseCount > 0 {
+		useStr = " " + useCountStyle.Render(fmt.Sprintf("%d×", e.UseCount))
+	}
+
+	line := fmt.Sprintf("%s %s%s%s%s %s", glyph, body, affordStr, extraStr, useStr, id)
+
+	if maxWidth > 0 && len(stripAnsi(line)) > maxWidth {
+		body = truncate(body, maxWidth-30)
+		line = fmt.Sprintf("%s %s%s%s%s %s", glyph, body, affordStr, extraStr, useStr, id)
+	}
+
+	return line
+}
+
+func detectAffordance(e *db.Entity) string {
+	if e.CardType == nil {
+		return ""
+	}
+	switch *e.CardType {
+	case db.CardSnippet:
+		return "code"
+	case db.CardTemplate:
+		return "fill"
+	case db.CardChecklist:
+		return "steps"
+	case db.CardDecision:
+		return "decide"
+	case db.CardLink:
+		return "link"
+	default:
+		return ""
+	}
+}

internal/tui/cards_test.go

@@ -0,0 +1,131 @@
+package tui
+
+import (
+	"testing"
+
+	"github.com/lerko/nib/internal/db"
+)
+
+func TestMatchesIntent(t *testing.T) {
+	snippet := db.CardSnippet
+	template := db.CardTemplate
+	checklist := db.CardChecklist
+	note := db.CardNote
+	link := db.CardLink
+	decision := db.CardDecision
+
+	tests := []struct {
+		name     string
+		cardType *db.CardType
+		intent   intent
+		want     bool
+	}{
+		{"all matches nil", nil, intentAll, true},
+		{"all matches snippet", &snippet, intentAll, true},
+		{"all matches template", &template, intentAll, true},
+
+		{"grab matches nil", nil, intentGrab, true},
+		{"grab matches snippet", &snippet, intentGrab, true},
+		{"grab rejects template", &template, intentGrab, false},
+		{"grab rejects note", &note, intentGrab, false},
+
+		{"read matches note", &note, intentRead, true},
+		{"read matches link", &link, intentRead, true},
+		{"read matches decision", &decision, intentRead, true},
+		{"read rejects snippet", &snippet, intentRead, false},
+		{"read rejects nil", nil, intentRead, false},
+
+		{"fill matches template", &template, intentFill, true},
+		{"fill matches checklist", &checklist, intentFill, true},
+		{"fill rejects snippet", &snippet, intentFill, false},
+		{"fill rejects nil", nil, intentFill, false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			e := &db.Entity{CardType: tt.cardType}
+			if got := matchesIntent(e, tt.intent); got != tt.want {
+				t.Fatalf("matchesIntent(%v, %v) = %v, want %v", tt.cardType, tt.intent, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestDetectAffordance(t *testing.T) {
+	snippet := db.CardSnippet
+	template := db.CardTemplate
+	checklist := db.CardChecklist
+	decision := db.CardDecision
+	link := db.CardLink
+	note := db.CardNote
+
+	tests := []struct {
+		name     string
+		cardType *db.CardType
+		want     string
+	}{
+		{"nil", nil, ""},
+		{"snippet", &snippet, "code"},
+		{"template", &template, "fill"},
+		{"checklist", &checklist, "steps"},
+		{"decision", &decision, "decide"},
+		{"link", &link, "link"},
+		{"note", &note, ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			e := &db.Entity{CardType: tt.cardType}
+			if got := detectAffordance(e); got != tt.want {
+				t.Fatalf("detectAffordance(%v) = %q, want %q", tt.cardType, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestIntentCycle(t *testing.T) {
+	order := []intent{intentAll, intentGrab, intentRead, intentFill, intentAll}
+	for i := 0; i < len(order)-1; i++ {
+		got := order[i].next()
+		if got != order[i+1] {
+			t.Fatalf("%v.next() = %v, want %v", order[i], got, order[i+1])
+		}
+	}
+}
+
+func TestApplyFilter_PinnedFirst(t *testing.T) {
+	snippet := db.CardSnippet
+	c := newCardsModel()
+	c.setEntities([]*db.Entity{
+		{ID: "1", Body: "a", CardType: &snippet},
+		{ID: "2", Body: "b", Pinned: true, CardType: &snippet},
+		{ID: "3", Body: "c", CardType: &snippet},
+	})
+
+	if len(c.filtered) != 3 {
+		t.Fatalf("expected 3 filtered, got %d", len(c.filtered))
+	}
+	if c.filtered[0].ID != "2" {
+		t.Fatalf("pinned entity should be first, got %s", c.filtered[0].ID)
+	}
+}
+
+func TestApplyFilter_CursorClamps(t *testing.T) {
+	snippet := db.CardSnippet
+	template := db.CardTemplate
+	c := newCardsModel()
+	c.setEntities([]*db.Entity{
+		{ID: "1", Body: "a", CardType: &snippet},
+		{ID: "2", Body: "b", CardType: &snippet},
+		{ID: "3", Body: "c", CardType: &template},
+	})
+	c.cursor = 2
+
+	c.setIntent(intentFill)
+	if len(c.filtered) != 1 {
+		t.Fatalf("expected 1 fill entity, got %d", len(c.filtered))
+	}
+	if c.cursor != 0 {
+		t.Fatalf("cursor should clamp to 0, got %d", c.cursor)
+	}
+}

internal/tui/commands.go

@@ -0,0 +1,266 @@
+package tui
+
+import (
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+
+	"github.com/atotto/clipboard"
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/lerko/nib/internal/carddata"
+	"github.com/lerko/nib/internal/db"
+)
+
+type entitiesLoadedMsg struct {
+	entities []*db.Entity
+}
+
+type entityCreatedMsg struct {
+	entity *db.Entity
+}
+
+type entityDeletedMsg struct {
+	id string
+}
+
+type entityUpdatedMsg struct {
+	entity *db.Entity
+	action string
+}
+
+type entityPromotedMsg struct {
+	id       string
+	cardType db.CardType
+}
+
+type entityDemotedMsg struct {
+	id string
+}
+
+type entityCopiedMsg struct{}
+
+type entityAbsorbedMsg struct {
+	targetID string
+}
+
+type absorbSourcesLoadedMsg struct {
+	targetID string
+	entities []*db.Entity
+}
+
+type stepsPersistedMsg struct{}
+
+type templateCopiedMsg struct{}
+
+type tagsLoadedMsg struct {
+	tags []db.TagCount
+}
+
+type editorFinishedMsg struct {
+	err error
+}
+
+type errMsg struct {
+	err error
+}
+
+func loadEntities(store *db.Store, params db.ListParams) tea.Cmd {
+	return func() tea.Msg {
+		entities, err := store.List(params)
+		if err != nil {
+			return errMsg{err}
+		}
+		return entitiesLoadedMsg{entities}
+	}
+}
+
+func createEntity(store *db.Store, e *db.Entity) tea.Cmd {
+	return func() tea.Msg {
+		if err := store.Create(e); err != nil {
+			return errMsg{err}
+		}
+		return entityCreatedMsg{e}
+	}
+}
+
+func deleteEntity(store *db.Store, id string) tea.Cmd {
+	return func() tea.Msg {
+		if _, err := store.SoftDelete(id); err != nil {
+			return errMsg{err}
+		}
+		return entityDeletedMsg{id}
+	}
+}
+
+func toggleTodo(store *db.Store, e *db.Entity) tea.Cmd {
+	return func() tea.Msg {
+		var update db.EntityUpdate
+		if e.CompletedAt == nil {
+			now := time.Now().UTC()
+			update = db.EntityUpdate{CompletedAt: &now}
+		} else {
+			update = db.EntityUpdate{ClearCompleted: true}
+		}
+
+		if err := store.Update(e.ID, &update); err != nil {
+			return errMsg{err}
+		}
+		updated, err := store.Get(e.ID)
+		if err != nil {
+			return errMsg{err}
+		}
+		action := "completed"
+		if e.CompletedAt != nil {
+			action = "reopened"
+		}
+		return entityUpdatedMsg{updated, action}
+	}
+}
+
+func pinEntity(store *db.Store, e *db.Entity) tea.Cmd {
+	return func() tea.Msg {
+		newPinned := !e.Pinned
+		update := db.EntityUpdate{Pinned: &newPinned}
+		if err := store.Update(e.ID, &update); err != nil {
+			return errMsg{err}
+		}
+		updated, err := store.Get(e.ID)
+		if err != nil {
+			return errMsg{err}
+		}
+		action := "pinned"
+		if !newPinned {
+			action = "unpinned"
+		}
+		return entityUpdatedMsg{updated, action}
+	}
+}
+
+func promoteEntity(store *db.Store, id string, ct db.CardType, body string) tea.Cmd {
+	return func() tea.Msg {
+		cd := carddata.GenerateCardData(ct, body)
+		if err := store.Promote(id, ct, cd); err != nil {
+			return errMsg{err}
+		}
+		return entityPromotedMsg{id, ct}
+	}
+}
+
+func demoteEntity(store *db.Store, id string) tea.Cmd {
+	return func() tea.Msg {
+		if err := store.Demote(id); err != nil {
+			return errMsg{err}
+		}
+		return entityDemotedMsg{id}
+	}
+}
+
+func copyToClipboard(store *db.Store, e *db.Entity) tea.Cmd {
+	return func() tea.Msg {
+		if err := clipboard.WriteAll(e.Body); err != nil {
+			return errMsg{err}
+		}
+		if err := store.IncrementUse(e.ID); err != nil {
+			return errMsg{err}
+		}
+		return entityCopiedMsg{}
+	}
+}
+
+func loadTags(store *db.Store) tea.Cmd {
+	return func() tea.Msg {
+		tags, err := store.ListTags(false)
+		if err != nil {
+			return errMsg{err}
+		}
+		return tagsLoadedMsg{tags}
+	}
+}
+
+func editInEditor(store *db.Store, e *db.Entity) tea.Cmd {
+	editorEnv := os.Getenv("EDITOR")
+	if editorEnv == "" {
+		editorEnv = "vi"
+	}
+	parts := strings.Fields(editorEnv)
+	editor, editorArgs := parts[0], parts[1:]
+
+	f, err := os.CreateTemp("", "nib-edit-*.md")
+	if err != nil {
+		return func() tea.Msg { return errMsg{err} }
+	}
+	if _, err := f.WriteString(e.Body); err != nil {
+		f.Close()
+		os.Remove(f.Name())
+		return func() tea.Msg { return errMsg{err} }
+	}
+	f.Close()
+
+	c := exec.Command(editor, append(editorArgs, f.Name())...)
+	return tea.ExecProcess(c, func(err error) tea.Msg {
+		defer os.Remove(f.Name())
+		if err != nil {
+			return editorFinishedMsg{err}
+		}
+
+		content, readErr := os.ReadFile(f.Name())
+		if readErr != nil {
+			return editorFinishedMsg{readErr}
+		}
+
+		newBody := string(content)
+		if newBody == e.Body {
+			return editorFinishedMsg{nil}
+		}
+
+		update := db.EntityUpdate{Body: &newBody}
+		if updateErr := store.Update(e.ID, &update); updateErr != nil {
+			return editorFinishedMsg{updateErr}
+		}
+
+		return editorFinishedMsg{nil}
+	})
+}
+
+func loadAbsorbSources(store *db.Store, targetID string) tea.Cmd {
+	return func() tea.Msg {
+		entities, err := store.List(db.DefaultListParams())
+		if err != nil {
+			return errMsg{err}
+		}
+		return absorbSourcesLoadedMsg{targetID, entities}
+	}
+}
+
+func absorbEntity(store *db.Store, targetID, sourceID string) tea.Cmd {
+	return func() tea.Msg {
+		if err := store.Absorb(targetID, sourceID); err != nil {
+			return errMsg{err}
+		}
+		return entityAbsorbedMsg{targetID}
+	}
+}
+
+func persistSteps(store *db.Store, entityID string, stepsJSON string) tea.Cmd {
+	return func() tea.Msg {
+		update := db.EntityUpdate{CardData: &stepsJSON}
+		if err := store.Update(entityID, &update); err != nil {
+			return errMsg{err}
+		}
+		return stepsPersistedMsg{}
+	}
+}
+
+func copyResolved(store *db.Store, entityID string, resolved string) tea.Cmd {
+	return func() tea.Msg {
+		if err := clipboard.WriteAll(resolved); err != nil {
+			return errMsg{err}
+		}
+		if err := store.IncrementUse(entityID); err != nil {
+			return errMsg{err}
+		}
+		return templateCopiedMsg{}
+	}
+}

internal/tui/confirm.go

@@ -0,0 +1,23 @@
+package tui
+
+import (
+	"fmt"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/lerko/nib/internal/display"
+)
+
+type confirmTimeoutMsg struct{}
+
+func confirmTimeout() tea.Cmd {
+	return tea.Tick(3*time.Second, func(time.Time) tea.Msg {
+		return confirmTimeoutMsg{}
+	})
+}
+
+func renderConfirm(entityID string) string {
+	short := display.FormatID(entityID)
+	return errorStyle.Render(fmt.Sprintf("delete %s? y to confirm, any key to cancel", short))
+}

internal/tui/detail.go

@@ -0,0 +1,239 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/lerko/nib/internal/db"
+	"github.com/lerko/nib/internal/display"
+)
+
+type detailMode int
+
+const (
+	detailPreview detailMode = iota
+	detailRun
+	detailFill
+)
+
+type detailModel struct {
+	entity *db.Entity
+	scroll int
+	height int
+	width  int
+	mode   detailMode
+	run    runModel
+	fill   fillModel
+}
+
+func newDetailModel() detailModel {
+	return detailModel{}
+}
+
+func (d *detailModel) setEntity(e *db.Entity) {
+	d.entity = e
+	d.scroll = 0
+	d.mode = detailPreview
+}
+
+func (d *detailModel) setSize(width, height int) {
+	d.width = width
+	d.height = height
+}
+
+func (d detailModel) update(msg tea.KeyMsg) (detailModel, tea.Cmd) {
+	switch d.mode {
+	case detailRun:
+		d.run = d.run.update(msg.String())
+		return d, nil
+	case detailFill:
+		var cmd tea.Cmd
+		d.fill, cmd = d.fill.update(msg)
+		return d, cmd
+	default:
+		switch msg.String() {
+		case "up", "k":
+			if d.scroll > 0 {
+				d.scroll--
+			}
+		case "down", "j":
+			d.scroll++
+		}
+		return d, nil
+	}
+}
+
+func (d detailModel) view(width int) string {
+	switch d.mode {
+	case detailRun:
+		return d.run.view(width)
+	case detailFill:
+		return d.fill.view(width)
+	default:
+		return d.previewView(width)
+	}
+}
+
+func (d detailModel) previewView(width int) string {
+	if d.entity == nil {
+		return ""
+	}
+
+	e := d.entity
+	var b strings.Builder
+
+	glyph := display.DisplayGlyph(e.Glyph, e.CardType)
+	header := fmt.Sprintf("%s  %s", glyph, display.FormatID(e.ID))
+	if e.CardType != nil {
+		header += "  " + affordanceStyle.Render(string(*e.CardType))
+	}
+	b.WriteString(detailHeaderStyle.Render(header))
+	b.WriteString("\n\n")
+
+	if e.Title != nil {
+		b.WriteString(detailBodyStyle.Render("title: " + *e.Title))
+		b.WriteString("\n")
+	}
+
+	b.WriteString(detailBodyStyle.Render(e.Body))
+	b.WriteString("\n")
+
+	if e.CardType != nil {
+		cardSection := renderCardData(e)
+		if cardSection != "" {
+			b.WriteString("\n")
+			b.WriteString(cardSection)
+		}
+	}
+
+	if len(e.Tags) > 0 {
+		tagParts := make([]string, len(e.Tags))
+		for i, t := range e.Tags {
+			tagParts[i] = tagStyle.Render("#" + t)
+		}
+		b.WriteString("\n")
+		b.WriteString(detailBodyStyle.Render(strings.Join(tagParts, " ")))
+		b.WriteString("\n")
+	}
+
+	b.WriteString("\n")
+	meta := fmt.Sprintf("created  %s", e.CreatedAt.Format(time.DateTime))
+	if e.ModifiedAt != e.CreatedAt {
+		meta += fmt.Sprintf("\nmodified %s", e.ModifiedAt.Format(time.DateTime))
+	}
+	if e.TimeAnchor != nil {
+		meta += fmt.Sprintf("\nanchored @%s", *e.TimeAnchor)
+	}
+	if e.Pinned {
+		meta += "\n" + pinnedStyle.Render("pinned")
+	}
+	if e.CardType != nil {
+		meta += fmt.Sprintf("\ncard     %s", *e.CardType)
+	}
+	if e.UseCount > 0 {
+		meta += fmt.Sprintf("\nused     %d×", e.UseCount)
+	}
+	if e.CompletedAt != nil {
+		meta += fmt.Sprintf("\ndone     %s", e.CompletedAt.Format(time.DateTime))
+	}
+	b.WriteString(idStyle.Render(meta))
+
+	lines := strings.Split(b.String(), "\n")
+	if d.scroll > 0 && d.scroll < len(lines) {
+		lines = lines[d.scroll:]
+	}
+	if d.height > 0 && len(lines) > d.height {
+		lines = lines[:d.height]
+	}
+
+	return strings.Join(lines, "\n")
+}
+
+func renderCardData(e *db.Entity) string {
+	if e.CardData == nil {
+		return ""
+	}
+
+	data, err := e.CardDataJSON()
+	if err != nil || data == nil {
+		return ""
+	}
+
+	var b strings.Builder
+
+	switch *e.CardType {
+	case db.CardChecklist:
+		steps, ok := data["steps"].([]interface{})
+		if !ok {
+			break
+		}
+		done := 0
+		for _, s := range steps {
+			step, ok := s.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			text, _ := step["text"].(string)
+			isDone, _ := step["done"].(bool)
+			if isDone {
+				done++
+				b.WriteString("  " + checkDoneStyle.Render("[✓] "+text) + "\n")
+			} else {
+				b.WriteString("  " + checkPendingStyle.Render("[ ] "+text) + "\n")
+			}
+		}
+		progress := fmt.Sprintf("  %d/%d steps", done, len(steps))
+		b.WriteString(detailLabelStyle.Render(progress))
+		b.WriteString("  " + helpStyle.Render("r:run"))
+
+	case db.CardTemplate:
+		slots, ok := data["slots"].([]interface{})
+		if !ok {
+			break
+		}
+		b.WriteString(detailLabelStyle.Render("  slots:") + "\n")
+		for _, s := range slots {
+			slot, ok := s.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			name, _ := slot["name"].(string)
+			def, _ := slot["default"].(string)
+			line := "  ${" + name + "}"
+			if def != "" {
+				line += "  " + detailValueStyle.Render("default: "+def)
+			}
+			b.WriteString(line + "\n")
+		}
+		b.WriteString("  " + helpStyle.Render("f:fill"))
+
+	case db.CardDecision:
+		if chose, ok := data["chose"].(string); ok && chose != "" {
+			b.WriteString("  " + detailLabelStyle.Render("chose: ") + detailValueStyle.Render(chose) + "\n")
+		}
+		if why, ok := data["why"].(string); ok && why != "" {
+			b.WriteString("  " + detailLabelStyle.Render("why: ") + detailValueStyle.Render(why) + "\n")
+		}
+		if rejected, ok := data["rejected"].([]interface{}); ok && len(rejected) > 0 {
+			items := make([]string, 0, len(rejected))
+			for _, r := range rejected {
+				if s, ok := r.(string); ok {
+					items = append(items, s)
+				}
+			}
+			if len(items) > 0 {
+				b.WriteString("  " + detailLabelStyle.Render("rejected: ") + detailValueStyle.Render(strings.Join(items, ", ")) + "\n")
+			}
+		}
+
+	case db.CardLink:
+		if url, ok := data["url"].(string); ok && url != "" {
+			b.WriteString("  " + detailLabelStyle.Render("↗ ") + detailValueStyle.Render(url) + "\n")
+		}
+	}
+
+	return b.String()
+}

internal/tui/fill.go

@@ -0,0 +1,152 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/lerko/nib/internal/carddata"
+)
+
+type fillSlot struct {
+	Name    string
+	Default string
+	Value   string
+}
+
+type fillModel struct {
+	slots    []fillSlot
+	active   int
+	body     string
+	entityID string
+	ti       textinput.Model
+}
+
+func newFillModel(entityID, body string) fillModel {
+	slots := discoverSlots(body)
+	m := fillModel{
+		slots:    slots,
+		body:     body,
+		entityID: entityID,
+	}
+	m.ti = textinput.New()
+	m.ti.CharLimit = 200
+	if len(slots) > 0 {
+		m.ti.Placeholder = slots[0].Name
+		m.ti.Focus()
+		if slots[0].Default != "" {
+			m.ti.SetValue(slots[0].Default)
+		}
+	}
+	return m
+}
+
+func discoverSlots(body string) []fillSlot {
+	matches := carddata.TemplateSlotRe.FindAllStringSubmatch(body, -1)
+	seen := map[string]bool{}
+	var slots []fillSlot
+	for _, m := range matches {
+		name := m[1]
+		if !seen[name] {
+			seen[name] = true
+			slots = append(slots, fillSlot{Name: name})
+		}
+	}
+	return slots
+}
+
+func (f fillModel) resolve() string {
+	result := f.body
+	for _, s := range f.slots {
+		val := s.Value
+		if val == "" {
+			val = "${" + s.Name + "}"
+		}
+		result = strings.ReplaceAll(result, "${"+s.Name+"}", val)
+	}
+	return result
+}
+
+func (f fillModel) update(msg tea.KeyMsg) (fillModel, tea.Cmd) {
+	switch msg.String() {
+	case "tab":
+		f.commitActive()
+		if f.active < len(f.slots)-1 {
+			f.active++
+		} else {
+			f.active = 0
+		}
+		f.loadActive()
+		return f, nil
+	case "shift+tab":
+		f.commitActive()
+		if f.active > 0 {
+			f.active--
+		} else {
+			f.active = len(f.slots) - 1
+		}
+		f.loadActive()
+		return f, nil
+	}
+
+	f.ti, _ = f.ti.Update(msg)
+	return f, nil
+}
+
+func (f *fillModel) commitActive() {
+	if f.active < len(f.slots) {
+		f.slots[f.active].Value = f.ti.Value()
+	}
+}
+
+func (f *fillModel) loadActive() {
+	if f.active < len(f.slots) {
+		s := f.slots[f.active]
+		f.ti.SetValue(s.Value)
+		f.ti.Placeholder = s.Name
+		f.ti.Focus()
+	}
+}
+
+func (f fillModel) view(width int) string {
+	if len(f.slots) == 0 {
+		return statusStyle.Render("no slots")
+	}
+
+	var b strings.Builder
+	header := fmt.Sprintf("⤓ filling   slot %d/%d", f.active+1, len(f.slots))
+	b.WriteString(detailHeaderStyle.Render(header))
+	b.WriteString("\n\n")
+
+	for i, slot := range f.slots {
+		name := detailLabelStyle.Render(slot.Name)
+		var val string
+		if i == f.active {
+			val = f.ti.View()
+		} else if slot.Value != "" {
+			val = detailValueStyle.Render(slot.Value)
+		} else {
+			val = idStyle.Render("(empty)")
+		}
+
+		if i == f.active {
+			b.WriteString(selectedItemStyle.Render(" " + name + "  " + val))
+		} else {
+			b.WriteString(listItemStyle.Render(name + "  " + val))
+		}
+		b.WriteString("\n")
+	}
+
+	b.WriteString("\n")
+	preview := f.resolve()
+	if len(preview) > width-4 {
+		preview = preview[:width-7] + "…"
+	}
+	b.WriteString(detailBodyStyle.Render(preview))
+	b.WriteString("\n\n")
+	b.WriteString(helpStyle.Render("tab:next  shift+tab:prev  enter:copy  esc:cancel"))
+
+	return b.String()
+}

internal/tui/fill_test.go

@@ -0,0 +1,81 @@
+package tui
+
+import (
+	"testing"
+)
+
+func TestDiscoverSlots(t *testing.T) {
+	tests := []struct {
+		name      string
+		body      string
+		wantNames []string
+	}{
+		{"no slots", "plain text", nil},
+		{"single slot", "Hello ${name}", []string{"name"}},
+		{"multiple slots", "${greeting} ${name}, welcome to ${place}", []string{"greeting", "name", "place"}},
+		{"duplicate slot deduped", "${x} and ${x} again", []string{"x"}},
+		{"adjacent slots", "${a}${b}", []string{"a", "b"}},
+		{"nested braces ignored", "${{bad}}", nil},
+		{"empty body", "", nil},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := discoverSlots(tt.body)
+			if len(tt.wantNames) == 0 && len(got) == 0 {
+				return
+			}
+			if len(got) != len(tt.wantNames) {
+				t.Fatalf("got %d slots, want %d", len(got), len(tt.wantNames))
+			}
+			for i, s := range got {
+				if s.Name != tt.wantNames[i] {
+					t.Fatalf("slot[%d].Name = %q, want %q", i, s.Name, tt.wantNames[i])
+				}
+			}
+		})
+	}
+}
+
+func TestResolve(t *testing.T) {
+	tests := []struct {
+		name  string
+		body  string
+		slots []fillSlot
+		want  string
+	}{
+		{
+			"all filled",
+			"Hello ${name}, welcome to ${place}",
+			[]fillSlot{{Name: "name", Value: "Alice"}, {Name: "place", Value: "Nib"}},
+			"Hello Alice, welcome to Nib",
+		},
+		{
+			"unfilled stays as placeholder",
+			"${greeting} ${name}",
+			[]fillSlot{{Name: "greeting", Value: "Hi"}, {Name: "name"}},
+			"Hi ${name}",
+		},
+		{
+			"no slots",
+			"plain text",
+			nil,
+			"plain text",
+		},
+		{
+			"repeated slot filled everywhere",
+			"${x} and ${x}",
+			[]fillSlot{{Name: "x", Value: "Y"}},
+			"Y and Y",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f := fillModel{body: tt.body, slots: tt.slots}
+			if got := f.resolve(); got != tt.want {
+				t.Fatalf("resolve() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}

internal/tui/filter.go

@@ -0,0 +1,84 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/lerko/nib/internal/db"
+)
+
+type filterModel struct {
+	tags   []db.TagCount
+	cursor int
+	height int
+}
+
+func newFilterModel() filterModel {
+	return filterModel{}
+}
+
+func (f *filterModel) setTags(tags []db.TagCount) {
+	f.tags = tags
+	f.cursor = 0
+}
+
+func (f *filterModel) setHeight(h int) {
+	f.height = h
+}
+
+func (f filterModel) selectedTag() string {
+	if len(f.tags) == 0 || f.cursor >= len(f.tags) {
+		return ""
+	}
+	return f.tags[f.cursor].Tag
+}
+
+func (f filterModel) update(key string) filterModel {
+	switch key {
+	case "up", "k":
+		if f.cursor > 0 {
+			f.cursor--
+		}
+	case "down", "j":
+		if f.cursor < len(f.tags)-1 {
+			f.cursor++
+		}
+	}
+	return f
+}
+
+func (f filterModel) view(width int) string {
+	if len(f.tags) == 0 {
+		return statusStyle.Render("no tags")
+	}
+
+	var b strings.Builder
+	b.WriteString(titleStyle.Render("filter by tag"))
+	b.WriteString("\n\n")
+
+	visible := f.height - 4
+	if visible <= 0 {
+		visible = 10
+	}
+
+	offset := 0
+	if f.cursor >= visible {
+		offset = f.cursor - visible + 1
+	}
+	end := min(offset+visible, len(f.tags))
+
+	for i := offset; i < end; i++ {
+		tc := f.tags[i]
+		tag := fmt.Sprintf("#%-20s %d", tc.Tag, tc.Count)
+		if i == f.cursor {
+			b.WriteString(selectedItemStyle.Render(" " + tagStyle.Render(tag)))
+		} else {
+			b.WriteString(listItemStyle.Render(tagStyle.Render(tag)))
+		}
+		if i < end-1 {
+			b.WriteString("\n")
+		}
+	}
+
+	return b.String()
+}

internal/tui/help.go

@@ -0,0 +1,86 @@
+package tui
+
+import "strings"
+
+func renderHelp(width, height int) string {
+	sections := []struct {
+		title string
+		binds [][2]string
+	}{
+		{"Navigation", [][2]string{
+			{"j/k ↑/↓", "move cursor"},
+			{"g/G home/end", "top / bottom"},
+			{"pgup/pgdn", "page up / down"},
+			{"enter", "view detail"},
+			{"esc", "back / clear filter"},
+		}},
+		{"Views", [][2]string{
+			{"1", "stream view"},
+			{"2", "cards view"},
+			{"s", "cycle sort (cards)"},
+			{"tab", "cycle intent (cards)"},
+		}},
+		{"Actions", [][2]string{
+			{"a", "add entity (or ?query to search)"},
+			{"d", "delete (with confirm)"},
+			{"x", "toggle todo completion"},
+			{"!", "toggle pin"},
+			{"#", "filter by tag"},
+			{"m", "absorb (merge into target)"},
+			{"p", "promote to card"},
+		}},
+		{"Detail View", [][2]string{
+			{"p", "promote to card"},
+			{"D", "demote to fluid"},
+			{"c", "copy to clipboard"},
+			{"e", "edit in $EDITOR"},
+			{"!", "toggle pin"},
+			{"r", "run checklist"},
+			{"f", "fill template"},
+		}},
+		{"Run Mode", [][2]string{
+			{"j/k", "move between steps"},
+			{"space", "toggle step"},
+			{"r", "reset all steps"},
+			{"esc", "save + exit"},
+		}},
+		{"Fill Mode", [][2]string{
+			{"tab", "next slot"},
+			{"shift+tab", "prev slot"},
+			{"enter", "copy resolved"},
+			{"esc", "cancel"},
+		}},
+		{"Split View", [][2]string{
+			{"l", "focus detail pane"},
+			{"h", "focus list pane"},
+			{"esc", "close detail / back"},
+		}},
+		{"Global", [][2]string{
+			{"?", "toggle help"},
+			{"q / ctrl+c", "quit"},
+		}},
+	}
+
+	var b strings.Builder
+	b.WriteString(detailHeaderStyle.Render("keybindings"))
+	b.WriteString("\n\n")
+
+	for _, s := range sections {
+		b.WriteString(titleStyle.Render(s.title))
+		b.WriteString("\n")
+		for _, bind := range s.binds {
+			key := helpKeyStyle.Render(bind[0])
+			desc := helpDescStyle.Render(bind[1])
+			b.WriteString("  " + key + "  " + desc + "\n")
+		}
+		b.WriteString("\n")
+	}
+
+	b.WriteString(helpStyle.Render("press ? or esc to close"))
+
+	lines := strings.Split(b.String(), "\n")
+	if len(lines) > height {
+		lines = lines[:height]
+	}
+	return strings.Join(lines, "\n")
+}

internal/tui/input.go

@@ -0,0 +1,176 @@
+package tui
+
+import (
+	"strings"
+
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/lerko/nib/internal/db"
+	"github.com/lerko/nib/internal/parse"
+)
+
+type inputResult struct {
+	entity *db.Entity
+	query  bool
+	body   string
+	tags   []string
+}
+
+type inputModel struct {
+	ti      textinput.Model
+	active  bool
+	preview *parse.Result
+}
+
+func newInputModel() inputModel {
+	ti := textinput.New()
+	ti.Placeholder = "capture a thought…"
+	ti.Prompt = inputPromptStyle.Render("› ")
+	ti.CharLimit = 500
+	return inputModel{ti: ti}
+}
+
+func (i *inputModel) focus() {
+	i.active = true
+	i.ti.Focus()
+}
+
+func (i *inputModel) reset() {
+	i.active = false
+	i.ti.SetValue("")
+	i.ti.Blur()
+	i.preview = nil
+}
+
+func (i inputModel) submit() *inputResult {
+	val := i.ti.Value()
+	if val == "" {
+		return nil
+	}
+
+	parsed, err := parse.Parse(val)
+	if err != nil {
+		return nil
+	}
+
+	if parsed.Query {
+		return &inputResult{
+			query: true,
+			body:  parsed.Body,
+			tags:  parsed.FilterTags,
+		}
+	}
+
+	e := &db.Entity{
+		Body:  parsed.Body,
+		Title: parsed.Title,
+		Glyph: db.Glyph(parsed.Glyph),
+		Tags:  parsed.Tags,
+	}
+	if parsed.TimeAnchor != nil {
+		e.TimeAnchor = parsed.TimeAnchor
+	}
+	if parsed.CardSuffix != nil {
+		ct := db.CardType(*parsed.CardSuffix)
+		e.CardType = &ct
+	}
+	if parsed.Pin {
+		e.Pinned = true
+	}
+	if parsed.Description != nil {
+		e.Description = parsed.Description
+	}
+
+	return &inputResult{entity: e}
+}
+
+func (i inputModel) updateKey(msg tea.KeyMsg) inputModel {
+	i.ti, _ = i.ti.Update(msg)
+	val := i.ti.Value()
+	if val != "" {
+		parsed, err := parse.Parse(val)
+		if err == nil {
+			i.preview = parsed
+		} else {
+			i.preview = nil
+		}
+	} else {
+		i.preview = nil
+	}
+	return i
+}
+
+func (i inputModel) view(width int) string {
+	var b strings.Builder
+	b.WriteString(drawerBorderStyle.Render(strings.Repeat("─", width)))
+	b.WriteString("\n")
+	b.WriteString(i.ti.View())
+	b.WriteString("\n")
+	b.WriteString(drawerHintsStyle.Render("enter:submit  esc:cancel  ?:search  -:todo  @:event  !:reminder"))
+	b.WriteString("\n")
+	b.WriteString(i.renderPreview(width))
+	return b.String()
+}
+
+func (i inputModel) renderPreview(width int) string {
+	if i.preview == nil {
+		return drawerPreviewStyle.Render("")
+	}
+
+	p := i.preview
+
+	if p.Query {
+		q := "?"
+		if p.Body != "" {
+			q += p.Body
+		}
+		for _, t := range p.FilterTags {
+			q += " #" + t
+		}
+		return drawerPreviewStyle.Render("search: " + q)
+	}
+
+	glyph := glyphForParsed(p.Glyph)
+	body := p.Body
+	if p.Title != nil {
+		body = *p.Title
+	}
+
+	var parts []string
+	parts = append(parts, glyph, body)
+	for _, t := range p.Tags {
+		parts = append(parts, tagStyle.Render("#"+t))
+	}
+	if p.Pin {
+		parts = append(parts, pinnedStyle.Render("•"))
+	}
+	if p.CardSuffix != nil {
+		parts = append(parts, affordanceStyle.Render(*p.CardSuffix))
+	}
+
+	line := strings.Join(parts, " ")
+	maxW := width - 4
+	if maxW > 0 && len(stripAnsi(line)) > maxW {
+		line = truncate(line, maxW)
+	}
+
+	return drawerPreviewStyle.Render(line)
+}
+
+func glyphForParsed(glyph string) string {
+	switch glyph {
+	case "todo":
+		return "○"
+	case "event":
+		return "◇"
+	case "reminder":
+		return "△"
+	default:
+		return "—"
+	}
+}
+
+func drawerLines() int {
+	return 3
+}

internal/tui/keys.go

@@ -0,0 +1,65 @@
+package tui
+
+import "github.com/charmbracelet/bubbles/key"
+
+type keyMap struct {
+	Up         key.Binding
+	Down       key.Binding
+	Enter      key.Binding
+	Back       key.Binding
+	Add        key.Binding
+	Delete     key.Binding
+	Quit       key.Binding
+	Help       key.Binding
+	PageUp     key.Binding
+	PageDn     key.Binding
+	Top        key.Binding
+	Bottom     key.Binding
+	Todo       key.Binding
+	Pin        key.Binding
+	Filter     key.Binding
+	Promote    key.Binding
+	Demote     key.Binding
+	Copy       key.Binding
+	Edit       key.Binding
+	Stream     key.Binding
+	Cards      key.Binding
+	Sort       key.Binding
+	Intent     key.Binding
+	Absorb     key.Binding
+	Run        key.Binding
+	Fill       key.Binding
+	FocusLeft  key.Binding
+	FocusRight key.Binding
+}
+
+var keys = keyMap{
+	Up:         key.NewBinding(key.WithKeys("up", "k"), key.WithHelp("↑/k", "up")),
+	Down:       key.NewBinding(key.WithKeys("down", "j"), key.WithHelp("↓/j", "down")),
+	Enter:      key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "view")),
+	Back:       key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "back")),
+	Add:        key.NewBinding(key.WithKeys("a"), key.WithHelp("a", "add")),
+	Delete:     key.NewBinding(key.WithKeys("d"), key.WithHelp("d", "delete")),
+	Quit:       key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
+	Help:       key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
+	PageUp:     key.NewBinding(key.WithKeys("pgup", "ctrl+u"), key.WithHelp("pgup", "page up")),
+	PageDn:     key.NewBinding(key.WithKeys("pgdown", "ctrl+d"), key.WithHelp("pgdn", "page down")),
+	Top:        key.NewBinding(key.WithKeys("home", "g"), key.WithHelp("home", "top")),
+	Bottom:     key.NewBinding(key.WithKeys("end", "G"), key.WithHelp("end", "bottom")),
+	Todo:       key.NewBinding(key.WithKeys("x"), key.WithHelp("x", "toggle todo")),
+	Pin:        key.NewBinding(key.WithKeys("!"), key.WithHelp("!", "toggle pin")),
+	Filter:     key.NewBinding(key.WithKeys("#"), key.WithHelp("#", "filter tag")),
+	Promote:    key.NewBinding(key.WithKeys("p"), key.WithHelp("p", "promote")),
+	Demote:     key.NewBinding(key.WithKeys("D"), key.WithHelp("D", "demote")),
+	Copy:       key.NewBinding(key.WithKeys("c"), key.WithHelp("c", "copy")),
+	Edit:       key.NewBinding(key.WithKeys("e"), key.WithHelp("e", "edit")),
+	Stream:     key.NewBinding(key.WithKeys("1"), key.WithHelp("1", "stream")),
+	Cards:      key.NewBinding(key.WithKeys("2"), key.WithHelp("2", "cards")),
+	Sort:       key.NewBinding(key.WithKeys("s"), key.WithHelp("s", "sort")),
+	Intent:     key.NewBinding(key.WithKeys("tab"), key.WithHelp("tab", "intent")),
+	Absorb:     key.NewBinding(key.WithKeys("m"), key.WithHelp("m", "absorb")),
+	Run:        key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "run checklist")),
+	Fill:       key.NewBinding(key.WithKeys("f"), key.WithHelp("f", "fill template")),
+	FocusLeft:  key.NewBinding(key.WithKeys("h"), key.WithHelp("h", "focus list")),
+	FocusRight: key.NewBinding(key.WithKeys("l"), key.WithHelp("l", "focus detail")),
+}

internal/tui/list.go

@@ -0,0 +1,269 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/lerko/nib/internal/db"
+	"github.com/lerko/nib/internal/display"
+)
+
+type listModel struct {
+	entities []*db.Entity
+	filtered []*db.Entity
+	cursor   int
+	offset   int
+	height   int
+	width    int
+}
+
+func newListModel() listModel {
+	return listModel{}
+}
+
+func (l *listModel) setEntities(entities []*db.Entity) {
+	l.entities = entities
+	l.filtered = nil
+	if l.cursor >= len(entities) {
+		l.cursor = max(0, len(entities)-1)
+	}
+}
+
+func (l *listModel) setSize(width, height int) {
+	l.width = width
+	l.height = height
+}
+
+func (l listModel) displayEntities() []*db.Entity {
+	if l.filtered != nil {
+		return l.filtered
+	}
+	return l.entities
+}
+
+func (l listModel) selected() *db.Entity {
+	ents := l.displayEntities()
+	if len(ents) == 0 || l.cursor >= len(ents) {
+		return nil
+	}
+	return ents[l.cursor]
+}
+
+func (l listModel) update(msg tea.KeyMsg) listModel {
+	switch msg.String() {
+	case "up", "k":
+		if l.cursor > 0 {
+			l.cursor--
+			if l.cursor < l.offset {
+				l.offset = l.cursor
+			}
+		}
+	case "down", "j":
+		if l.cursor < len(l.displayEntities())-1 {
+			l.cursor++
+			visible := l.visibleCount()
+			if l.cursor >= l.offset+visible {
+				l.offset = l.cursor - visible + 1
+			}
+		}
+	case "home", "g":
+		l.cursor = 0
+		l.offset = 0
+	case "end", "G":
+		l.cursor = max(0, len(l.displayEntities())-1)
+		visible := l.visibleCount()
+		if l.cursor >= visible {
+			l.offset = l.cursor - visible + 1
+		}
+	case "pgup", "ctrl+u":
+		l.cursor = max(0, l.cursor-l.visibleCount())
+		if l.cursor < l.offset {
+			l.offset = l.cursor
+		}
+	case "pgdown", "ctrl+d":
+		l.cursor = min(len(l.displayEntities())-1, l.cursor+l.visibleCount())
+		visible := l.visibleCount()
+		if l.cursor >= l.offset+visible {
+			l.offset = l.cursor - visible + 1
+		}
+	}
+	return l
+}
+
+const dateGutterWidth = 9
+
+func (l listModel) view(width int) string {
+	ents := l.displayEntities()
+	if len(ents) == 0 {
+		return statusStyle.Render("no entities")
+	}
+
+	groups := groupByDate(ents)
+	entityWidth := width - 4 - dateGutterWidth
+
+	type displayLine struct {
+		text      string
+		entityIdx int
+	}
+
+	var lines []displayLine
+	entityIdx := 0
+	for _, g := range groups {
+		for i, e := range g.entities {
+			var gutter string
+			if i == 0 {
+				gutter = gutterStyle.Render(padRight(g.label, 6) + " │ ")
+			} else {
+				gutter = gutterStyle.Render("       │ ")
+			}
+			line := gutter + renderEntity(e, entityWidth)
+			lines = append(lines, displayLine{
+				text:      line,
+				entityIdx: entityIdx,
+			})
+			entityIdx++
+		}
+	}
+
+	visible := l.visibleCount()
+	offset := 0
+	if l.cursor >= visible {
+		offset = l.cursor - visible + 1
+	}
+
+	var b strings.Builder
+	end := min(offset+visible, len(lines))
+	for i := offset; i < end; i++ {
+		dl := lines[i]
+		if dl.entityIdx == l.cursor {
+			b.WriteString(selectedItemStyle.Render(" " + dl.text))
+		} else {
+			b.WriteString(listItemStyle.Render(dl.text))
+		}
+		if i < end-1 {
+			b.WriteString("\n")
+		}
+	}
+
+	return b.String()
+}
+
+func (l listModel) visibleCount() int {
+	if l.height <= 0 {
+		return 20
+	}
+	return l.height
+}
+
+type dateGroup struct {
+	label    string
+	entities []*db.Entity
+}
+
+func groupByDate(entities []*db.Entity) []dateGroup {
+	var groups []dateGroup
+	var current *dateGroup
+
+	for _, e := range entities {
+		label := formatDateLabel(e.CreatedAt)
+		if current == nil || current.label != label {
+			if current != nil {
+				groups = append(groups, *current)
+			}
+			current = &dateGroup{label: label}
+		}
+		current.entities = append(current.entities, e)
+	}
+	if current != nil {
+		groups = append(groups, *current)
+	}
+	return groups
+}
+
+func formatDateLabel(t time.Time) string {
+	return strings.ToLower(t.Format("Jan 2"))
+}
+
+func padRight(s string, n int) string {
+	r := []rune(s)
+	if len(r) >= n {
+		return string(r[:n])
+	}
+	return s + strings.Repeat(" ", n-len(r))
+}
+
+func renderEntity(e *db.Entity, maxWidth int) string {
+	glyphStr := display.DisplayGlyph(e.Glyph, e.CardType)
+	style := glyphStyle
+	if e.Glyph == db.GlyphTodo && e.CompletedAt != nil {
+		glyphStr = "●"
+		style = completedGlyphStyle
+	}
+	glyph := style.Render(glyphStr)
+
+	id := idStyle.Render("[" + display.FormatID(e.ID) + "]")
+
+	body := e.Body
+	if e.Title != nil {
+		body = *e.Title
+	}
+
+	var extras []string
+	if e.Pinned {
+		extras = append(extras, pinnedStyle.Render("•"))
+	}
+	if len(e.Tags) > 0 {
+		tagParts := make([]string, len(e.Tags))
+		for i, t := range e.Tags {
+			tagParts[i] = tagStyle.Render("#" + t)
+		}
+		extras = append(extras, strings.Join(tagParts, " "))
+	}
+
+	extraStr := ""
+	if len(extras) > 0 {
+		extraStr = " " + strings.Join(extras, " ")
+	}
+
+	line := fmt.Sprintf("%s %s%s %s", glyph, body, extraStr, id)
+
+	if maxWidth > 0 && len(stripAnsi(line)) > maxWidth {
+		body = truncate(body, maxWidth-20)
+		line = fmt.Sprintf("%s %s%s %s", glyph, body, extraStr, id)
+	}
+
+	return line
+}
+
+func truncate(s string, maxLen int) string {
+	if maxLen <= 3 {
+		return "…"
+	}
+	runes := []rune(s)
+	if len(runes) <= maxLen {
+		return s
+	}
+	return string(runes[:maxLen-1]) + "…"
+}
+
+func stripAnsi(s string) string {
+	var b strings.Builder
+	inEsc := false
+	for _, r := range s {
+		if r == '\x1b' {
+			inEsc = true
+			continue
+		}
+		if inEsc {
+			if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') {
+				inEsc = false
+			}
+			continue
+		}
+		b.WriteRune(r)
+	}
+	return b.String()
+}

internal/tui/list_test.go

@@ -0,0 +1,94 @@
+package tui
+
+import (
+	"testing"
+	"time"
+
+	"github.com/lerko/nib/internal/db"
+)
+
+func TestGroupByDate(t *testing.T) {
+	may19 := time.Date(2026, 5, 19, 10, 0, 0, 0, time.UTC)
+	may19b := time.Date(2026, 5, 19, 14, 0, 0, 0, time.UTC)
+	may18 := time.Date(2026, 5, 18, 9, 0, 0, 0, time.UTC)
+
+	entities := []*db.Entity{
+		{ID: "1", CreatedAt: may19, Body: "a"},
+		{ID: "2", CreatedAt: may19b, Body: "b"},
+		{ID: "3", CreatedAt: may18, Body: "c"},
+	}
+
+	groups := groupByDate(entities)
+	if len(groups) != 2 {
+		t.Fatalf("expected 2 groups, got %d", len(groups))
+	}
+	if len(groups[0].entities) != 2 {
+		t.Fatalf("first group should have 2 entities, got %d", len(groups[0].entities))
+	}
+	if len(groups[1].entities) != 1 {
+		t.Fatalf("second group should have 1 entity, got %d", len(groups[1].entities))
+	}
+	if groups[0].label != "may 19" {
+		t.Fatalf("first group label = %q, want %q", groups[0].label, "may 19")
+	}
+}
+
+func TestGroupByDate_Empty(t *testing.T) {
+	groups := groupByDate(nil)
+	if len(groups) != 0 {
+		t.Fatalf("expected 0 groups, got %d", len(groups))
+	}
+}
+
+func TestGroupByDate_SingleEntity(t *testing.T) {
+	e := []*db.Entity{{ID: "1", CreatedAt: time.Now(), Body: "solo"}}
+	groups := groupByDate(e)
+	if len(groups) != 1 || len(groups[0].entities) != 1 {
+		t.Fatal("single entity should produce 1 group with 1 entity")
+	}
+}
+
+func TestTruncate(t *testing.T) {
+	tests := []struct {
+		name   string
+		input  string
+		maxLen int
+		want   string
+	}{
+		{"short enough", "hello", 10, "hello"},
+		{"exact length", "hello", 5, "hello"},
+		{"truncated", "hello world", 6, "hello…"},
+		{"very short max", "hello", 3, "…"},
+		{"unicode", "héllo wörld", 7, "héllo …"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := truncate(tt.input, tt.maxLen)
+			if got != tt.want {
+				t.Fatalf("truncate(%q, %d) = %q, want %q", tt.input, tt.maxLen, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestStripAnsi(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		{"no ansi", "hello", "hello"},
+		{"with color", "\x1b[31mred\x1b[0m", "red"},
+		{"empty", "", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := stripAnsi(tt.input)
+			if got != tt.want {
+				t.Fatalf("stripAnsi(%q) = %q, want %q", tt.input, got, tt.want)
+			}
+		})
+	}
+}

internal/tui/model.go

@@ -0,0 +1,908 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+
+	"github.com/lerko/nib/internal/db"
+)
+
+type viewState int
+
+const (
+	stateList viewState = iota
+	stateDetail
+	stateInput
+	stateTagFilter
+	stateConfirm
+	statePromote
+	stateAbsorb
+)
+
+type viewMode int
+
+const (
+	modeStream viewMode = iota
+	modeCards
+)
+
+type cardsSort int
+
+const (
+	sortNewest cardsSort = iota
+	sortOldest
+	sortMostUsed
+)
+
+func (s cardsSort) String() string {
+	switch s {
+	case sortOldest:
+		return "oldest"
+	case sortMostUsed:
+		return "most used"
+	default:
+		return "newest"
+	}
+}
+
+func (s cardsSort) next() cardsSort {
+	switch s {
+	case sortNewest:
+		return sortOldest
+	case sortOldest:
+		return sortMostUsed
+	default:
+		return sortNewest
+	}
+}
+
+type focusPane int
+
+const (
+	focusList focusPane = iota
+	focusDetail
+)
+
+type model struct {
+	store  *db.Store
+	state  viewState
+	mode   viewMode
+	width  int
+	height int
+
+	list     listModel
+	cards    cardsModel
+	detail   detailModel
+	input    inputModel
+	filter   filterModel
+	promote  promoteModel
+	absorb   absorbModel
+	showHelp bool
+
+	focus       focusPane
+	splitDetail bool
+
+	filterTag   string
+	confirmID   string
+	cardsSort   cardsSort
+	searchQuery string
+	searchTags  []string
+
+	status string
+	err    error
+}
+
+func newModel(store *db.Store) model {
+	return model{
+		store:  store,
+		state:  stateList,
+		mode:   modeStream,
+		list:   newListModel(),
+		cards:  newCardsModel(),
+		detail: newDetailModel(),
+		input:  newInputModel(),
+		filter: newFilterModel(),
+	}
+}
+
+func (m model) Init() tea.Cmd {
+	return loadEntities(m.store, m.listParams())
+}
+
+func (m model) listParams() db.ListParams {
+	p := db.DefaultListParams()
+	if m.filterTag != "" {
+		p.Tag = &m.filterTag
+	}
+	if m.mode == modeCards {
+		p.CardsOnly = true
+		switch m.cardsSort {
+		case sortNewest:
+			p.Sort = "created"
+			p.Order = "desc"
+		case sortOldest:
+			p.Sort = "created"
+			p.Order = "asc"
+		case sortMostUsed:
+			p.Sort = "use_count"
+			p.Order = "desc"
+		}
+	}
+	return p
+}
+
+func (m model) hasSearch() bool {
+	return m.searchQuery != "" || len(m.searchTags) > 0
+}
+
+func (m *model) applySearch() {
+	if m.mode == modeCards {
+		filtered := filterEntities(m.cards.entities, m.searchQuery, m.searchTags)
+		m.cards.filtered = nil
+		var pinned, rest []*db.Entity
+		for _, e := range filtered {
+			if !matchesIntent(e, m.cards.intent) {
+				continue
+			}
+			if e.Pinned {
+				pinned = append(pinned, e)
+			} else {
+				rest = append(rest, e)
+			}
+		}
+		m.cards.filtered = append(pinned, rest...)
+		if m.cards.cursor >= len(m.cards.filtered) {
+			m.cards.cursor = max(0, len(m.cards.filtered)-1)
+		}
+	} else {
+		m.list.filtered = filterEntities(m.list.entities, m.searchQuery, m.searchTags)
+	}
+}
+
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		m.width = msg.Width
+		m.height = msg.Height
+		if !m.isSplit() && m.splitDetail {
+			m.state = stateDetail
+			m.splitDetail = false
+			m.focus = focusList
+		}
+		m.recalcSizes()
+		return m, nil
+
+	case entitiesLoadedMsg:
+		if m.mode == modeCards {
+			m.cards.setEntities(msg.entities)
+		} else {
+			m.list.setEntities(msg.entities)
+		}
+		if m.hasSearch() {
+			m.applySearch()
+		}
+		m.err = nil
+		return m, nil
+
+	case entityCreatedMsg:
+		m.state = stateList
+		m.input.reset()
+		m.recalcSizes()
+		m.status = "created"
+		return m, loadEntities(m.store, m.listParams())
+
+	case entityDeletedMsg:
+		m.status = "deleted"
+		m.state = stateList
+		return m, loadEntities(m.store, m.listParams())
+
+	case entityUpdatedMsg:
+		m.status = msg.action
+		if m.state == stateDetail {
+			m.detail.setEntity(msg.entity)
+		}
+		return m, loadEntities(m.store, m.listParams())
+
+	case entityPromotedMsg:
+		m.status = fmt.Sprintf("promoted → %s", msg.cardType)
+		m.state = stateList
+		return m, loadEntities(m.store, m.listParams())
+
+	case entityDemotedMsg:
+		m.status = "demoted → fluid"
+		return m, m.reloadDetail(msg.id)
+
+	case entityCopiedMsg:
+		m.status = "copied"
+		return m, nil
+
+	case entityAbsorbedMsg:
+		m.status = "absorbed"
+		m.state = stateList
+		return m, loadEntities(m.store, m.listParams())
+
+	case absorbSourcesLoadedMsg:
+		m.absorb = newAbsorbModel(msg.targetID)
+		m.absorb.setSources(msg.entities)
+		m.absorb.setHeight(m.contentHeight())
+		m.state = stateAbsorb
+		return m, nil
+
+	case stepsPersistedMsg:
+		m.status = "steps saved"
+		m.detail.mode = detailPreview
+		return m, m.reloadDetail(m.detail.entity.ID)
+
+	case templateCopiedMsg:
+		m.status = "copied resolved"
+		m.detail.mode = detailPreview
+		return m, loadEntities(m.store, m.listParams())
+
+	case tagsLoadedMsg:
+		m.filter.setTags(msg.tags)
+		m.state = stateTagFilter
+		return m, nil
+
+	case editorFinishedMsg:
+		if msg.err != nil {
+			m.err = msg.err
+		} else {
+			m.status = "updated"
+		}
+		return m, m.reloadAfterEdit()
+
+	case confirmTimeoutMsg:
+		if m.state == stateConfirm {
+			m.state = stateList
+			m.confirmID = ""
+		}
+		return m, nil
+
+	case errMsg:
+		m.err = msg.err
+		return m, nil
+
+	case tea.KeyMsg:
+		m.err = nil
+		switch m.state {
+		case stateInput:
+			return m.updateInput(msg)
+		case stateTagFilter:
+			return m.updateTagFilter(msg)
+		case stateConfirm:
+			return m.updateConfirm(msg)
+		case statePromote:
+			return m.updatePromote(msg)
+		case stateAbsorb:
+			return m.updateAbsorb(msg)
+		default:
+			return m.updateKeys(msg)
+		}
+	}
+
+	return m, nil
+}
+
+func (m model) updateKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	if m.showHelp {
+		if msg.String() == "?" || msg.String() == "esc" || msg.String() == "q" {
+			m.showHelp = false
+		}
+		return m, nil
+	}
+
+	if m.splitDetail && m.state == stateList {
+		switch msg.String() {
+		case "l":
+			if m.focus == focusList {
+				m.focus = focusDetail
+				return m, nil
+			}
+		case "h":
+			if m.focus == focusDetail {
+				m.focus = focusList
+				return m, nil
+			}
+		case "esc":
+			if m.focus == focusDetail {
+				m.focus = focusList
+				return m, nil
+			}
+			m.splitDetail = false
+			m.recalcSizes()
+			return m, nil
+		}
+
+		if m.focus == focusDetail {
+			switch msg.String() {
+			case "j", "k", "up", "down", "pgup", "pgdown", "ctrl+u", "ctrl+d":
+				var cmd tea.Cmd
+				m.detail, cmd = m.detail.update(msg)
+				return m, cmd
+			case "c":
+				if m.detail.entity != nil {
+					return m, copyToClipboard(m.store, m.detail.entity)
+				}
+				return m, nil
+			case "e":
+				if m.detail.entity != nil && m.detail.mode == detailPreview {
+					return m, editInEditor(m.store, m.detail.entity)
+				}
+				return m, nil
+			case "p":
+				if m.detail.entity != nil && m.detail.entity.CardType == nil {
+					m.promote = newPromoteModel(m.detail.entity.ID, m.detail.entity.Body)
+					m.state = statePromote
+					m.splitDetail = false
+					m.recalcSizes()
+					return m, nil
+				}
+				return m, nil
+			case "D":
+				if m.detail.entity != nil && m.detail.entity.CardType != nil {
+					return m, demoteEntity(m.store, m.detail.entity.ID)
+				}
+				return m, nil
+			case "!":
+				if m.detail.entity != nil {
+					return m, pinEntity(m.store, m.detail.entity)
+				}
+				return m, nil
+			case "r":
+				if m.detail.entity != nil && m.detail.mode == detailPreview {
+					if m.detail.entity.CardType != nil && *m.detail.entity.CardType == db.CardChecklist {
+						m.detail.run = newRunModel(m.detail.entity.ID, m.detail.entity.CardData)
+						m.detail.mode = detailRun
+						m.splitDetail = false
+						m.state = stateDetail
+						m.recalcSizes()
+						return m, nil
+					}
+				}
+				return m, nil
+			case "f":
+				if m.detail.entity != nil && m.detail.mode == detailPreview {
+					if m.detail.entity.CardType != nil && *m.detail.entity.CardType == db.CardTemplate {
+						m.detail.fill = newFillModel(m.detail.entity.ID, m.detail.entity.Body)
+						m.detail.mode = detailFill
+						m.splitDetail = false
+						m.state = stateDetail
+						m.recalcSizes()
+						return m, m.detail.fill.ti.Focus()
+					}
+				}
+				return m, nil
+			}
+		}
+	}
+
+	switch msg.String() {
+	case "ctrl+c":
+		return m, tea.Quit
+
+	case "q":
+		if m.state == stateList {
+			return m, tea.Quit
+		}
+		return m, nil
+
+	case "?":
+		m.showHelp = true
+		return m, nil
+
+	case "1":
+		if m.mode != modeStream {
+			m.mode = modeStream
+			m.state = stateList
+			m.status = ""
+			return m, loadEntities(m.store, m.listParams())
+		}
+		return m, nil
+
+	case "2":
+		if m.mode != modeCards {
+			m.mode = modeCards
+			m.state = stateList
+			m.status = ""
+			return m, loadEntities(m.store, m.listParams())
+		}
+		return m, nil
+
+	case "s":
+		if m.mode == modeCards && m.state == stateList {
+			m.cardsSort = m.cardsSort.next()
+			m.status = "sort: " + m.cardsSort.String()
+			return m, loadEntities(m.store, m.listParams())
+		}
+		return m, nil
+
+	case "tab":
+		if m.mode == modeCards && m.state == stateList {
+			m.cards.setIntent(m.cards.intent.next())
+			if m.hasSearch() {
+				m.applySearch()
+			}
+			return m, nil
+		}
+		return m, nil
+
+	case "a":
+		if m.state == stateList {
+			m.state = stateInput
+			m.input.focus()
+			m.recalcSizes()
+			return m, m.input.ti.Focus()
+		}
+
+	case "esc":
+		if m.state == stateDetail {
+			if m.detail.mode == detailRun {
+				var cmd tea.Cmd
+				if m.detail.run.dirty {
+					cmd = persistSteps(m.store, m.detail.run.entityID, m.detail.run.stepsJSON())
+				}
+				m.detail.mode = detailPreview
+				if m.isSplit() {
+					m.state = stateList
+					m.splitDetail = true
+					m.focus = focusList
+					m.recalcSizes()
+				}
+				return m, cmd
+			}
+			if m.detail.mode == detailFill {
+				m.detail.mode = detailPreview
+				if m.isSplit() {
+					m.state = stateList
+					m.splitDetail = true
+					m.focus = focusList
+					m.recalcSizes()
+				}
+				return m, nil
+			}
+			if m.isSplit() {
+				m.state = stateList
+				m.splitDetail = true
+				m.focus = focusList
+				m.recalcSizes()
+				return m, nil
+			}
+			m.state = stateList
+			return m, nil
+		}
+		if m.state == stateList && m.hasSearch() {
+			m.searchQuery = ""
+			m.searchTags = nil
+			m.status = ""
+			if m.mode == modeCards {
+				m.cards.applyFilter()
+			} else {
+				m.list.filtered = nil
+			}
+			return m, nil
+		}
+		if m.state == stateList && m.filterTag != "" {
+			m.filterTag = ""
+			m.status = ""
+			return m, loadEntities(m.store, m.listParams())
+		}
+		return m, nil
+
+	case "d":
+		if m.state == stateList {
+			if e := m.selectedEntity(); e != nil {
+				m.confirmID = e.ID
+				m.state = stateConfirm
+				return m, confirmTimeout()
+			}
+		}
+		return m, nil
+
+	case "x":
+		if m.state == stateList {
+			if e := m.selectedEntity(); e != nil && e.Glyph == db.GlyphTodo {
+				return m, toggleTodo(m.store, e)
+			}
+		}
+		return m, nil
+
+	case "!":
+		e := m.selectedEntity()
+		if e != nil {
+			return m, pinEntity(m.store, e)
+		}
+		return m, nil
+
+	case "#":
+		if m.state == stateList {
+			if m.filterTag != "" {
+				m.filterTag = ""
+				m.status = ""
+				return m, loadEntities(m.store, m.listParams())
+			}
+			return m, loadTags(m.store)
+		}
+		return m, nil
+
+	case "m":
+		e := m.selectedEntity()
+		if e != nil {
+			if e.CardType != nil {
+				m.status = "target must be fluid"
+				return m, nil
+			}
+			return m, loadAbsorbSources(m.store, e.ID)
+		}
+		return m, nil
+
+	case "p":
+		e := m.selectedEntity()
+		if e != nil {
+			if e.CardType != nil {
+				m.status = "already a card"
+				return m, nil
+			}
+			m.promote = newPromoteModel(e.ID, e.Body)
+			m.state = statePromote
+			return m, nil
+		}
+		return m, nil
+
+	case "D":
+		if m.state == stateDetail && m.detail.entity != nil {
+			if m.detail.entity.CardType == nil {
+				m.status = "already fluid"
+				return m, nil
+			}
+			return m, demoteEntity(m.store, m.detail.entity.ID)
+		}
+		return m, nil
+
+	case "c":
+		if m.state == stateDetail && m.detail.entity != nil {
+			return m, copyToClipboard(m.store, m.detail.entity)
+		}
+		return m, nil
+
+	case "e":
+		if m.state == stateDetail && m.detail.entity != nil && m.detail.mode == detailPreview {
+			return m, editInEditor(m.store, m.detail.entity)
+		}
+		return m, nil
+
+	case "r":
+		if m.state == stateDetail && m.detail.entity != nil && m.detail.mode == detailPreview {
+			if m.detail.entity.CardType != nil && *m.detail.entity.CardType == db.CardChecklist {
+				m.detail.run = newRunModel(m.detail.entity.ID, m.detail.entity.CardData)
+				m.detail.mode = detailRun
+				return m, nil
+			}
+		}
+		return m, nil
+
+	case "f":
+		if m.state == stateDetail && m.detail.entity != nil && m.detail.mode == detailPreview {
+			if m.detail.entity.CardType != nil && *m.detail.entity.CardType == db.CardTemplate {
+				m.detail.fill = newFillModel(m.detail.entity.ID, m.detail.entity.Body)
+				m.detail.mode = detailFill
+				return m, m.detail.fill.ti.Focus()
+			}
+		}
+		return m, nil
+
+	case "enter":
+		if m.state == stateDetail && m.detail.mode == detailFill {
+			m.detail.fill.commitActive()
+			resolved := m.detail.fill.resolve()
+			return m, copyResolved(m.store, m.detail.fill.entityID, resolved)
+		}
+		if m.state == stateList {
+			if e := m.selectedEntity(); e != nil {
+				m.detail.setEntity(e)
+				if m.isSplit() {
+					m.splitDetail = true
+					m.focus = focusDetail
+					m.recalcSizes()
+				} else {
+					m.state = stateDetail
+				}
+			}
+		}
+		return m, nil
+	}
+
+	switch m.state {
+	case stateList:
+		if m.mode == modeCards {
+			m.cards = m.cards.update(msg)
+		} else {
+			m.list = m.list.update(msg)
+		}
+		if m.splitDetail {
+			if e := m.selectedEntity(); e != nil {
+				m.detail.setEntity(e)
+			}
+		}
+	case stateDetail:
+		var cmd tea.Cmd
+		m.detail, cmd = m.detail.update(msg)
+		return m, cmd
+	}
+	return m, nil
+}
+
+func (m model) updateInput(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "esc":
+		m.state = stateList
+		m.input.reset()
+		m.recalcSizes()
+		return m, nil
+	case "enter":
+		result := m.input.submit()
+		if result == nil {
+			return m, nil
+		}
+		if result.query {
+			m.searchQuery = result.body
+			m.searchTags = result.tags
+			m.state = stateList
+			m.input.reset()
+			m.recalcSizes()
+			m.applySearch()
+			return m, nil
+		}
+		if result.entity != nil {
+			return m, createEntity(m.store, result.entity)
+		}
+		return m, nil
+	}
+
+	m.input = m.input.updateKey(msg)
+	return m, nil
+}
+
+func (m model) updateTagFilter(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "esc", "q":
+		m.state = stateList
+		return m, nil
+	case "enter":
+		tag := m.filter.selectedTag()
+		if tag != "" {
+			m.filterTag = tag
+			m.state = stateList
+			return m, loadEntities(m.store, m.listParams())
+		}
+		return m, nil
+	default:
+		m.filter = m.filter.update(msg.String())
+		return m, nil
+	}
+}
+
+func (m model) updateConfirm(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	id := m.confirmID
+	m.confirmID = ""
+	m.state = stateList
+
+	if msg.String() == "y" && id != "" {
+		return m, deleteEntity(m.store, id)
+	}
+	return m, nil
+}
+
+func (m model) updatePromote(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "esc", "q":
+		m.state = stateList
+		return m, nil
+	case "enter":
+		ct := m.promote.selectedType()
+		return m, promoteEntity(m.store, m.promote.entityID, ct, m.promote.body)
+	default:
+		m.promote = m.promote.update(msg.String())
+		return m, nil
+	}
+}
+
+func (m model) updateAbsorb(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "esc", "q":
+		m.state = stateList
+		return m, nil
+	case "enter":
+		source := m.absorb.selectedSource()
+		if source != nil {
+			return m, absorbEntity(m.store, m.absorb.targetID, source.ID)
+		}
+		return m, nil
+	default:
+		m.absorb = m.absorb.update(msg)
+		return m, nil
+	}
+}
+
+func (m model) View() string {
+	if m.showHelp {
+		return renderHelp(m.width, m.height)
+	}
+
+	var content string
+	switch m.state {
+	case stateList, stateInput, stateConfirm:
+		listContent := m.listContent()
+		if m.splitDetail {
+			lw, rw := m.splitWidths()
+			ch := m.contentHeight()
+			left := lipgloss.NewStyle().Width(lw).Height(ch).Render(listContent)
+			sep := m.renderSeparator()
+			right := lipgloss.NewStyle().Width(rw).Height(ch).Render(m.detail.view(rw))
+			content = lipgloss.JoinHorizontal(lipgloss.Top, left, sep, right)
+		} else {
+			content = listContent
+		}
+	case stateDetail:
+		content = m.detail.view(m.width)
+	case stateTagFilter:
+		content = m.filter.view(m.width)
+	case statePromote:
+		content = m.promote.view(m.width)
+	case stateAbsorb:
+		content = m.absorb.view(m.width)
+	}
+
+	header := m.headerView()
+	footer := m.footerView()
+
+	return header + "\n" + content + "\n" + footer
+}
+
+func (m model) listContent() string {
+	if m.mode == modeCards {
+		lw := m.width
+		if m.splitDetail {
+			lw, _ = m.splitWidths()
+		}
+		return m.cards.view(lw)
+	}
+	lw := m.width
+	if m.splitDetail {
+		lw, _ = m.splitWidths()
+	}
+	return m.list.view(lw)
+}
+
+func (m model) headerView() string {
+	header := titleStyle.Render("nib")
+
+	modeName := "stream"
+	if m.mode == modeCards {
+		modeName = "cards"
+	}
+	header += " " + modeStyle.Render(modeName)
+
+	if m.filterTag != "" {
+		header += " " + filterPillStyle.Render("#"+m.filterTag)
+	}
+
+	if m.hasSearch() {
+		pill := "?"
+		if m.searchQuery != "" {
+			pill += m.searchQuery
+		}
+		for _, t := range m.searchTags {
+			pill += " #" + t
+		}
+		header += " " + searchPillStyle.Render(pill)
+	}
+
+	if m.mode == modeCards && m.cards.intent != intentAll {
+		header += " " + affordanceStyle.Render(m.cards.intent.String())
+	}
+
+	if m.mode == modeCards {
+		header += " " + idStyle.Render("("+m.cardsSort.String()+")")
+	}
+
+	return header
+}
+
+func (m model) footerView() string {
+	if m.state == stateInput {
+		return m.input.view(m.width)
+	}
+
+	if m.state == stateConfirm {
+		return renderConfirm(m.confirmID)
+	}
+
+	if m.err != nil {
+		return errorStyle.Render("error: " + m.err.Error())
+	}
+
+	if m.status != "" {
+		return statusStyle.Render(m.status) + "  " + helpStyle.Render(contextHints(m))
+	}
+
+	return renderStatusBar(m, m.width)
+}
+
+func (m model) contentHeight() int {
+	return m.height - 3 - m.drawerHeight()
+}
+
+func (m model) drawerHeight() int {
+	if m.state == stateInput {
+		return drawerLines()
+	}
+	return 0
+}
+
+func (m *model) recalcSizes() {
+	ch := m.contentHeight()
+	if m.isSplit() && m.splitDetail {
+		lw, rw := m.splitWidths()
+		m.list.setSize(lw, ch)
+		m.cards.setSize(lw, ch)
+		m.detail.setSize(rw, ch)
+	} else {
+		m.list.setSize(m.width, ch)
+		m.cards.setSize(m.width, ch)
+		m.detail.setSize(m.width, ch)
+	}
+	m.filter.setHeight(ch)
+}
+
+func (m model) isSplit() bool {
+	return m.width >= 100
+}
+
+func (m model) splitWidths() (int, int) {
+	left := m.width * 40 / 100
+	right := m.width - left - 1
+	return left, right
+}
+
+func (m model) renderSeparator() string {
+	ch := m.contentHeight()
+	lines := make([]string, ch)
+	for i := range lines {
+		lines[i] = "│"
+	}
+	return separatorStyle.Render(strings.Join(lines, "\n"))
+}
+
+func (m model) selectedEntity() *db.Entity {
+	switch {
+	case m.state == stateDetail:
+		return m.detail.entity
+	case m.mode == modeCards:
+		return m.cards.selected()
+	default:
+		return m.list.selected()
+	}
+}
+
+func (m model) reloadDetail(id string) tea.Cmd {
+	return tea.Batch(
+		loadEntities(m.store, m.listParams()),
+		func() tea.Msg {
+			e, err := m.store.Get(id)
+			if err != nil {
+				return errMsg{err}
+			}
+			return entityUpdatedMsg{e, ""}
+		},
+	)
+}
+
+func (m model) reloadAfterEdit() tea.Cmd {
+	if m.detail.entity == nil {
+		return loadEntities(m.store, m.listParams())
+	}
+	return m.reloadDetail(m.detail.entity.ID)
+}

internal/tui/promote.go

@@ -0,0 +1,84 @@
+package tui
+
+import (
+	"github.com/lerko/nib/internal/carddata"
+	"github.com/lerko/nib/internal/db"
+	"github.com/lerko/nib/internal/display"
+)
+
+type promoteOption struct {
+	cardType db.CardType
+	label    string
+	group    string
+}
+
+var promoteOptions = []promoteOption{
+	{db.CardSnippet, "snippet", "grab"},
+	{db.CardNote, "note", "read"},
+	{db.CardLink, "link", "read"},
+	{db.CardDecision, "decision", "read"},
+	{db.CardTemplate, "template", "fill"},
+	{db.CardChecklist, "checklist", "fill"},
+}
+
+type promoteModel struct {
+	cursor    int
+	entityID  string
+	body      string
+	suggested *db.CardType
+}
+
+func newPromoteModel(entityID, body string) promoteModel {
+	return promoteModel{
+		entityID:  entityID,
+		body:      body,
+		suggested: carddata.DetectCardType(body),
+	}
+}
+
+func (p promoteModel) selectedType() db.CardType {
+	return promoteOptions[p.cursor].cardType
+}
+
+func (p promoteModel) update(key string) promoteModel {
+	switch key {
+	case "up", "k":
+		if p.cursor > 0 {
+			p.cursor--
+		}
+	case "down", "j":
+		if p.cursor < len(promoteOptions)-1 {
+			p.cursor++
+		}
+	}
+	return p
+}
+
+func (p promoteModel) view(width int) string {
+	var b string
+	b += titleStyle.Render("promote to card") + "\n\n"
+
+	currentGroup := ""
+	for i, opt := range promoteOptions {
+		if opt.group != currentGroup {
+			currentGroup = opt.group
+			b += dateHeaderStyle.Render("── "+currentGroup+" ──") + "\n"
+		}
+
+		glyph := display.DisplayGlyph(db.GlyphNote, &opt.cardType)
+		label := glyph + " " + opt.label
+
+		if p.suggested != nil && *p.suggested == opt.cardType {
+			label += " " + affordanceStyle.Render("*")
+		}
+
+		if i == p.cursor {
+			b += selectedItemStyle.Render(" "+label) + "\n"
+		} else {
+			b += listItemStyle.Render(label) + "\n"
+		}
+	}
+
+	b += "\n" + helpStyle.Render("enter:select  esc:cancel")
+	return b
+}

internal/tui/run.go

@@ -0,0 +1,116 @@
+package tui
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+type runStep struct {
+	Text string `json:"text"`
+	Done bool   `json:"done"`
+}
+
+type runModel struct {
+	steps    []runStep
+	cursor   int
+	entityID string
+	dirty    bool
+}
+
+func newRunModel(entityID string, cardData *string) runModel {
+	m := runModel{entityID: entityID}
+	m.steps = parseChecklist(cardData)
+	return m
+}
+
+func parseChecklist(cardData *string) []runStep {
+	if cardData == nil {
+		return nil
+	}
+	var data struct {
+		Steps []runStep `json:"steps"`
+	}
+	if err := json.Unmarshal([]byte(*cardData), &data); err != nil {
+		return nil
+	}
+	return data.Steps
+}
+
+func (r runModel) stepsJSON() string {
+	b, _ := json.Marshal(map[string]any{"steps": r.steps})
+	return string(b)
+}
+
+func (r runModel) doneCount() int {
+	n := 0
+	for _, s := range r.steps {
+		if s.Done {
+			n++
+		}
+	}
+	return n
+}
+
+func (r runModel) update(key string) runModel {
+	switch key {
+	case "up", "k":
+		if r.cursor > 0 {
+			r.cursor--
+		}
+	case "down", "j":
+		if r.cursor < len(r.steps)-1 {
+			r.cursor++
+		}
+	case " ":
+		if r.cursor < len(r.steps) {
+			r.steps[r.cursor].Done = !r.steps[r.cursor].Done
+			r.dirty = true
+		}
+	case "r":
+		for i := range r.steps {
+			r.steps[i].Done = false
+		}
+		r.dirty = true
+	}
+	return r
+}
+
+func (r runModel) view(width int) string {
+	if len(r.steps) == 0 {
+		return statusStyle.Render("no steps")
+	}
+
+	var b strings.Builder
+	done := r.doneCount()
+	total := len(r.steps)
+	pct := 0
+	if total > 0 {
+		pct = done * 100 / total
+	}
+
+	header := fmt.Sprintf("▶ running   %d/%d done (%d%%)", done, total, pct)
+	b.WriteString(detailHeaderStyle.Render(header))
+	b.WriteString("\n\n")
+
+	for i, step := range r.steps {
+		var line string
+		if step.Done {
+			line = checkDoneStyle.Render("[✓] " + step.Text)
+		} else {
+			line = checkPendingStyle.Render("[ ] " + step.Text)
+		}
+
+		if i == r.cursor {
+			b.WriteString(selectedItemStyle.Render(" " + line))
+		} else {
+			b.WriteString(listItemStyle.Render(line))
+		}
+		b.WriteString("\n")
+	}
+
+	b.WriteString("\n")
+	b.WriteString(helpStyle.Render("space:toggle  r:reset  esc:save+exit"))
+
+	return b.String()
+}

internal/tui/run_test.go

@@ -0,0 +1,65 @@
+package tui
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestParseChecklist(t *testing.T) {
+	tests := []struct {
+		name     string
+		cardData *string
+		wantLen  int
+	}{
+		{"nil data", nil, 0},
+		{"empty JSON", ptr("{}"), 0},
+		{"malformed JSON", ptr("{bad"), 0},
+		{"valid steps", ptr(`{"steps":[{"text":"step 1","done":false},{"text":"step 2","done":true}]}`), 2},
+		{"empty steps array", ptr(`{"steps":[]}`), 0},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := parseChecklist(tt.cardData)
+			if len(got) != tt.wantLen {
+				t.Fatalf("parseChecklist() returned %d steps, want %d", len(got), tt.wantLen)
+			}
+		})
+	}
+}
+
+func TestParseChecklist_PreservesDoneState(t *testing.T) {
+	data := `{"steps":[{"text":"first","done":false},{"text":"second","done":true}]}`
+	steps := parseChecklist(&data)
+	if steps[0].Done {
+		t.Fatal("step 0 should not be done")
+	}
+	if !steps[1].Done {
+		t.Fatal("step 1 should be done")
+	}
+	if steps[0].Text != "first" || steps[1].Text != "second" {
+		t.Fatalf("texts wrong: %q, %q", steps[0].Text, steps[1].Text)
+	}
+}
+
+func TestDoneCount(t *testing.T) {
+	r := newRunModel("id", ptr(`{"steps":[{"label":"a","done":true},{"label":"b","done":false},{"label":"c","done":true}]}`))
+	if got := r.doneCount(); got != 2 {
+		t.Fatalf("doneCount() = %d, want 2", got)
+	}
+}
+
+func TestStepsJSON_Roundtrip(t *testing.T) {
+	r := newRunModel("id", ptr(`{"steps":[{"text":"test","done":false}]}`))
+	out := r.stepsJSON()
+
+	var parsed struct {
+		Steps []runStep `json:"steps"`
+	}
+	if err := json.Unmarshal([]byte(out), &parsed); err != nil {
+		t.Fatalf("stepsJSON() produced invalid JSON: %v", err)
+	}
+	if len(parsed.Steps) != 1 || parsed.Steps[0].Text != "test" {
+		t.Fatalf("roundtrip failed: %+v", parsed.Steps)
+	}
+}

internal/tui/search.go

@@ -0,0 +1,55 @@
+package tui
+
+import (
+	"strings"
+
+	"github.com/lerko/nib/internal/db"
+)
+
+func filterEntities(entities []*db.Entity, query string, tags []string) []*db.Entity {
+	if query == "" && len(tags) == 0 {
+		return entities
+	}
+
+	query = strings.ToLower(query)
+	lowerTags := make([]string, len(tags))
+	for i, t := range tags {
+		lowerTags[i] = strings.ToLower(t)
+	}
+
+	var result []*db.Entity
+	for _, e := range entities {
+		if !matchesSearch(e, query, lowerTags) {
+			continue
+		}
+		result = append(result, e)
+	}
+	return result
+}
+
+func matchesSearch(e *db.Entity, query string, tags []string) bool {
+	if len(tags) > 0 {
+		eTags := make(map[string]bool, len(e.Tags))
+		for _, t := range e.Tags {
+			eTags[strings.ToLower(t)] = true
+		}
+		for _, t := range tags {
+			if !eTags[t] {
+				return false
+			}
+		}
+	}
+
+	if query == "" {
+		return true
+	}
+
+	haystack := strings.ToLower(e.Body)
+	if e.Title != nil {
+		haystack += " " + strings.ToLower(*e.Title)
+	}
+	if e.Description != nil {
+		haystack += " " + strings.ToLower(*e.Description)
+	}
+	return strings.Contains(haystack, query)
+}

internal/tui/search_test.go

@@ -0,0 +1,70 @@
+package tui
+
+import (
+	"testing"
+
+	"github.com/lerko/nib/internal/db"
+)
+
+func ptr[T any](v T) *T { return &v }
+
+func TestFilterEntities(t *testing.T) {
+	entities := []*db.Entity{
+		{ID: "1", Body: "buy groceries", Tags: []string{"errand", "food"}},
+		{ID: "2", Body: "read chapter 5", Title: ptr("Go Book"), Tags: []string{"study"}},
+		{ID: "3", Body: "fix login bug", Description: ptr("auth middleware broken"), Tags: []string{"work", "urgent"}},
+		{ID: "4", Body: "empty tags"},
+	}
+
+	tests := []struct {
+		name    string
+		query   string
+		tags    []string
+		wantIDs []string
+	}{
+		{"no filter returns all", "", nil, []string{"1", "2", "3", "4"}},
+		{"query matches body", "groceries", nil, []string{"1"}},
+		{"query case insensitive", "GROCERIES", nil, []string{"1"}},
+		{"query matches title", "go book", nil, []string{"2"}},
+		{"query matches description", "middleware", nil, []string{"3"}},
+		{"query no match", "nonexistent", nil, nil},
+		{"single tag filter", "", []string{"study"}, []string{"2"}},
+		{"multi tag filter all present", "", []string{"work", "urgent"}, []string{"3"}},
+		{"multi tag filter partial miss", "", []string{"work", "food"}, nil},
+		{"tag filter no match", "", []string{"missing"}, nil},
+		{"query plus tag", "fix", []string{"work"}, []string{"3"}},
+		{"query plus tag mismatch", "groceries", []string{"work"}, nil},
+		{"entity with nil title and description", "empty", nil, []string{"4"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := filterEntities(entities, tt.query, tt.tags)
+			gotIDs := make([]string, len(got))
+			for i, e := range got {
+				gotIDs[i] = e.ID
+			}
+			if len(tt.wantIDs) == 0 && len(gotIDs) == 0 {
+				return
+			}
+			if len(gotIDs) != len(tt.wantIDs) {
+				t.Fatalf("got %v, want %v", gotIDs, tt.wantIDs)
+			}
+			for i := range gotIDs {
+				if gotIDs[i] != tt.wantIDs[i] {
+					t.Fatalf("got %v, want %v", gotIDs, tt.wantIDs)
+				}
+			}
+		})
+	}
+}
+
+func TestMatchesSearch_NilFields(t *testing.T) {
+	e := &db.Entity{Body: "hello world"}
+	if !matchesSearch(e, "hello", nil) {
+		t.Fatal("should match body")
+	}
+	if matchesSearch(e, "title", nil) {
+		t.Fatal("should not match nil title")
+	}
+}

internal/tui/statusbar.go

@@ -0,0 +1,71 @@
+package tui
+
+import (
+	"fmt"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+func renderStatusBar(m model, width int) string {
+	left := countText(m)
+	right := contextHints(m)
+
+	leftRendered := statusStyle.Render(left)
+	rightRendered := helpStyle.Render(right)
+
+	gap := width - lipgloss.Width(leftRendered) - lipgloss.Width(rightRendered)
+	if gap < 0 {
+		gap = 0
+	}
+
+	pad := lipgloss.NewStyle().Width(gap).Render("")
+	return leftRendered + pad + rightRendered
+}
+
+func countText(m model) string {
+	var total int
+	if m.mode == modeCards {
+		total = len(m.cards.filtered)
+	} else {
+		total = len(m.list.displayEntities())
+	}
+	if m.filterTag != "" {
+		return fmt.Sprintf("%d entities #%s", total, m.filterTag)
+	}
+	return fmt.Sprintf("%d entities", total)
+}
+
+func contextHints(m model) string {
+	switch m.state {
+	case stateDetail:
+		switch m.detail.mode {
+		case detailRun:
+			return "space:toggle  j/k:nav  r:reset  esc:save+exit"
+		case detailFill:
+			return "tab:next  shift+tab:prev  enter:copy  esc:cancel"
+		default:
+			return "p:promote D:demote c:copy e:edit r:run f:fill !:pin esc:back"
+		}
+	case stateInput:
+		return ""
+	case stateTagFilter:
+		return "j/k:nav enter:select esc:cancel"
+	case stateConfirm:
+		return "y:confirm n:cancel"
+	case statePromote:
+		return "j/k:nav enter:select esc:cancel"
+	case stateAbsorb:
+		return "j/k:nav enter:absorb esc:cancel"
+	default:
+		if m.splitDetail {
+			if m.focus == focusDetail {
+				return "h:list c:copy e:edit p:promote D:demote !:pin esc:back"
+			}
+			return "l:detail a:add d:del #:filter esc:close ?:help q:quit"
+		}
+		if m.mode == modeCards {
+			return "1:stream 2:cards s:sort tab:intent a:add ?:help q:quit"
+		}
+		return "1:stream 2:cards a:add/?search m:absorb d:del #:filter ?:help q:quit"
+	}
+}

internal/tui/styles.go

@@ -0,0 +1,125 @@
+package tui
+
+import "github.com/charmbracelet/lipgloss"
+
+var (
+	subtle    = lipgloss.AdaptiveColor{Light: "#D9DCCF", Dark: "#383838"}
+	highlight = lipgloss.AdaptiveColor{Light: "#874BFD", Dark: "#7D56F4"}
+	dim       = lipgloss.AdaptiveColor{Light: "#A49FA5", Dark: "#777777"}
+
+	titleStyle = lipgloss.NewStyle().
+			Bold(true).
+			Foreground(highlight).
+			PaddingLeft(1)
+
+	statusStyle = lipgloss.NewStyle().
+			Foreground(dim).
+			PaddingLeft(1)
+
+	listItemStyle = lipgloss.NewStyle().
+			PaddingLeft(2)
+
+	selectedItemStyle = lipgloss.NewStyle().
+				PaddingLeft(1).
+				Bold(true).
+				Foreground(highlight).
+				SetString("›")
+
+	glyphStyle = lipgloss.NewStyle().
+			Width(2)
+
+	completedGlyphStyle = lipgloss.NewStyle().
+				Width(2).
+				Foreground(dim)
+
+	tagStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "#43BF6D", Dark: "#73F59F"})
+
+	idStyle = lipgloss.NewStyle().
+		Foreground(dim)
+
+	inputPromptStyle = lipgloss.NewStyle().
+				Foreground(highlight).
+				Bold(true)
+
+	detailHeaderStyle = lipgloss.NewStyle().
+				Bold(true).
+				Foreground(highlight).
+				MarginBottom(1)
+
+	detailBodyStyle = lipgloss.NewStyle().
+			PaddingLeft(2).
+			PaddingTop(1)
+
+	helpStyle = lipgloss.NewStyle().
+			Foreground(dim).
+			PaddingLeft(1)
+
+	errorStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#FF0000")).
+			PaddingLeft(1)
+
+	dateHeaderStyle = lipgloss.NewStyle().
+			Foreground(dim).
+			PaddingLeft(1)
+
+	pinnedStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "#D4A017", Dark: "#FFD700"})
+
+	filterPillStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "#43BF6D", Dark: "#73F59F"}).
+			Bold(true)
+
+	helpKeyStyle = lipgloss.NewStyle().
+			Foreground(highlight).
+			Bold(true).
+			Width(18)
+
+	helpDescStyle = lipgloss.NewStyle().
+			Foreground(dim)
+
+	affordanceStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "#5B8EF0", Dark: "#7AAFFF"}).
+			Bold(true)
+
+	useCountStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "#B07D3A", Dark: "#D4A54A"})
+
+	modeStyle = lipgloss.NewStyle().
+			Foreground(dim).
+			Bold(true)
+
+	detailLabelStyle = lipgloss.NewStyle().
+				Foreground(highlight).
+				Bold(true)
+
+	detailValueStyle = lipgloss.NewStyle().
+				Foreground(lipgloss.AdaptiveColor{Light: "#555555", Dark: "#BBBBBB"})
+
+	checkDoneStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "#43BF6D", Dark: "#73F59F"})
+
+	checkPendingStyle = lipgloss.NewStyle().
+				Foreground(dim)
+
+	searchPillStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "#E06C75", Dark: "#E06C75"}).
+			Bold(true)
+
+	gutterStyle = lipgloss.NewStyle().
+			Foreground(dim)
+
+	drawerBorderStyle = lipgloss.NewStyle().
+				Foreground(dim)
+
+	drawerHintsStyle = lipgloss.NewStyle().
+				Foreground(dim).
+				PaddingLeft(2)
+
+	drawerPreviewStyle = lipgloss.NewStyle().
+				Foreground(lipgloss.AdaptiveColor{Light: "#555555", Dark: "#AAAAAA"}).
+				PaddingLeft(2)
+
+	separatorStyle = lipgloss.NewStyle().
+			Foreground(dim)
+)

internal/tui/tui.go

@@ -0,0 +1,20 @@
+package tui
+
+import (
+	"fmt"
+	"os"
+
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/lerko/nib/internal/db"
+)
+
+func Run(store *db.Store) error {
+	m := newModel(store)
+	p := tea.NewProgram(m, tea.WithAltScreen(), tea.WithMouseCellMotion())
+	if _, err := p.Run(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		return err
+	}
+	return nil
+}

testdata/demo.json

@@ -0,0 +1,133 @@
+[
+  {
+    "body": "Buy milk, eggs, and bread",
+    "glyph": "todo",
+    "tags": ["errands", "grocery"]
+  },
+  {
+    "body": "Fix leaking kitchen faucet",
+    "glyph": "todo",
+    "tags": ["home", "plumbing"]
+  },
+  {
+    "body": "Review pull request for auth refactor",
+    "glyph": "todo",
+    "tags": ["work", "code-review"],
+    "pinned": true
+  },
+  {
+    "body": "Dentist appointment",
+    "glyph": "event",
+    "time_anchor": "2026-05-20T10:00:00Z",
+    "tags": ["health"]
+  },
+  {
+    "body": "Team standup",
+    "glyph": "event",
+    "time_anchor": "2026-05-19T09:00:00Z",
+    "tags": ["work", "meetings"]
+  },
+  {
+    "body": "Kubernetes clusters use etcd as the backing store for all cluster data including state, config, and metadata.",
+    "glyph": "note",
+    "tags": ["devops", "k8s"]
+  },
+  {
+    "body": "The Go scheduler uses M:N threading — M goroutines multiplexed onto N OS threads.",
+    "glyph": "note",
+    "tags": ["golang", "til"]
+  },
+  {
+    "body": "Solar panel installation — get 3 quotes before June",
+    "glyph": "note",
+    "tags": ["home", "solar"],
+    "pinned": true
+  },
+  {
+    "body": "Submit quarterly tax estimate",
+    "glyph": "todo",
+    "time_anchor": "2026-06-15T00:00:00Z",
+    "tags": ["finance"]
+  },
+  {
+    "body": "Backup NAS to offsite",
+    "glyph": "todo",
+    "completed": true,
+    "tags": ["homelab", "backups"]
+  },
+  {
+    "body": "version: '3'\nservices:\n  traefik:\n    image: traefik:v2.10\n    ports:\n      - \"${host_port:-443}:443\"\n    volumes:\n      - /var/run/docker.sock:/var/run/docker.sock\n    environment:\n      - CF_DNS_API_TOKEN=${cf_token}\n    labels:\n      - traefik.http.routers.dashboard.rule=Host(`${dashboard_domain}`)",
+    "glyph": "note",
+    "title": "Traefik Reverse Proxy",
+    "description": "Production-ready compose with auto-TLS renewal",
+    "card_type": "snippet",
+    "card_data": "{\"language\":\"yaml\",\"source\":\"personal\"}",
+    "tags": ["homelab", "docker", "traefik"]
+  },
+  {
+    "body": "## Weekly Review\n- [ ] Clear inbox\n- [ ] Review calendar\n- [ ] Update project boards\n- [ ] Plan next week",
+    "glyph": "note",
+    "title": "Weekly Review Checklist",
+    "card_type": "checklist",
+    "card_data": "{\"items\":4,\"completed\":0}",
+    "tags": ["productivity", "routine"]
+  },
+  {
+    "body": "PRAGMA journal_mode = WAL;\nPRAGMA busy_timeout = ${timeout_ms:-5000};\nPRAGMA synchronous = ${sync_mode:-NORMAL};",
+    "glyph": "note",
+    "title": "SQLite Concurrency",
+    "description": "Key settings for multi-reader single-writer",
+    "card_type": "snippet",
+    "card_data": "{\"language\":\"sql\",\"source\":\"docs\"}",
+    "tags": ["sqlite", "til"]
+  },
+  {
+    "body": "Decided to use CalVer (YYYY.0M.MICRO) instead of SemVer for nib releases. Rationale: nib is an app not a library, no API stability contract needed.",
+    "glyph": "note",
+    "title": "Versioning Strategy",
+    "card_type": "decision",
+    "card_data": "{\"status\":\"accepted\",\"date\":\"2026-04-01\"}",
+    "tags": ["nib", "decisions"]
+  },
+  {
+    "body": "https://github.com/charmbracelet/bubbletea",
+    "glyph": "note",
+    "title": "Bubbletea TUI Framework",
+    "description": "Go TUI framework based on Elm architecture",
+    "card_type": "link",
+    "card_data": "{\"url\":\"https://github.com/charmbracelet/bubbletea\",\"domain\":\"github.com\"}",
+    "tags": ["golang", "tui", "libraries"]
+  },
+  {
+    "body": "Remember to rotate API keys every 90 days",
+    "glyph": "todo",
+    "time_anchor": "2026-07-01T00:00:00Z",
+    "tags": ["security", "homelab"]
+  },
+  {
+    "body": "Interesting idea: build a CLI that converts natural language to nib captures using local LLM",
+    "glyph": "note",
+    "tags": ["ideas", "nib", "ai"]
+  },
+  {
+    "body": "Garage door opener warranty expires in August",
+    "glyph": "event",
+    "time_anchor": "2026-08-15T00:00:00Z",
+    "tags": ["home"]
+  },
+  {
+    "body": "Consolidate all docker services to single compose file",
+    "glyph": "todo",
+    "tags": ["homelab", "docker"],
+    "deleted": true
+  },
+  {
+    "body": "## ${project_name}\n- [ ] Create repo at ${git_host}/${org}/${project_name}\n- [ ] Add CI pipeline\n- [ ] Write README\n- [ ] Add LICENSE (${license_type})\n- [ ] First release tag",
+    "glyph": "note",
+    "title": "Project Bootstrap",
+    "description": "Standard checklist for starting new projects",
+    "card_type": "template",
+    "card_data": "{\"items\":5}",
+    "tags": ["productivity", "dev"]
+  }
+]

web/favicon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <path d="M16 1 L28 16 L20 30 L16 24 L12 30 L4 16 Z" fill="#c8942a"/>
+</svg>

web/fonts.css

@@ -0,0 +1,67 @@
+/* ── Self-hosted fonts ─────────────────────────────── */
+
+/* Satoshi — primary sans */
+@font-face {
+    font-family: 'Satoshi';
+    src: url('/fonts/Satoshi-Light.woff2') format('woff2');
+    font-weight: 300;
+    font-style: normal;
+    font-display: swap;
+}
+
+@font-face {
+    font-family: 'Satoshi';
+    src: url('/fonts/Satoshi-Regular.woff2') format('woff2');
+    font-weight: 400;
+    font-style: normal;
+    font-display: swap;
+}
+
+@font-face {
+    font-family: 'Satoshi';
+    src: url('/fonts/Satoshi-Medium.woff2') format('woff2');
+    font-weight: 500;
+    font-style: normal;
+    font-display: swap;
+}
+
+@font-face {
+    font-family: 'Satoshi';
+    src: url('/fonts/Satoshi-Bold.woff2') format('woff2');
+    font-weight: 700;
+    font-style: normal;
+    font-display: swap;
+}
+
+/* JetBrains Mono — mono */
+@font-face {
+    font-family: 'JetBrains Mono';
+    src: url('/fonts/JetBrainsMono-Light.woff2') format('woff2');
+    font-weight: 300;
+    font-style: normal;
+    font-display: swap;
+}
+
+@font-face {
+    font-family: 'JetBrains Mono';
+    src: url('/fonts/JetBrainsMono-Regular.woff2') format('woff2');
+    font-weight: 400;
+    font-style: normal;
+    font-display: swap;
+}
+
+@font-face {
+    font-family: 'JetBrains Mono';
+    src: url('/fonts/JetBrainsMono-Medium.woff2') format('woff2');
+    font-weight: 500;
+    font-style: normal;
+    font-display: swap;
+}
+
+@font-face {
+    font-family: 'JetBrains Mono';
+    src: url('/fonts/JetBrainsMono-Bold.woff2') format('woff2');
+    font-weight: 700;
+    font-style: normal;
+    font-display: swap;
+}

web/index.html

@@ -1,31 +1,37 @@
 <!DOCTYPE html>
-<html lang="en">
+<html lang="en" data-theme="dark">
 <head>
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <title>nib</title>
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg">
+    <link rel="stylesheet" href="/fonts.css">
     <link rel="stylesheet" href="/style.css">
 </head>
 <body>
     <div id="app">
         <header>
             <div class="header-left">
-                <h1 class="logo">nib</h1>
+                <span class="logo">nib</span>
                 <nav>
                     <button data-view="stream" class="nav-btn active">stream</button>
                     <button data-view="cards" class="nav-btn">cards</button>
                 </nav>
             </div>
-            <form id="capture-bar" autocomplete="off">
+            <div class="header-search">
-                <input type="text" id="capture-input" placeholder="capture... (n to focus)" spellcheck="false">
+                <input type="text" id="search-input" placeholder="? search  #tag" spellcheck="false">
-            </form>
+            </div>
+            <button class="theme-toggle" id="theme-toggle" title="toggle theme">◑</button>
         </header>
         <main>
             <aside id="tag-rail"></aside>
+            <div class="resize-handle" data-panel="rail"></div>
             <section id="entity-panel">
                 <div id="month-nav"></div>
                 <div id="entity-list"></div>
+                <div id="capture-bar"></div>
             </section>
+            <div class="resize-handle" data-panel="peek"></div>
             <aside id="detail-pane">
                 <div class="detail-empty">select an entity</div>
             </aside>
@@ -36,27 +42,47 @@
         <div class="modal-backdrop"></div>
         <div class="modal-content">
             <h3>promote to card</h3>
+            <div class="modal-sub" id="promote-sub"></div>
             <div class="type-picker">
-                <button data-type="snippet" class="type-btn">
+                <div class="type-col">
-                    <span class="type-glyph">◆</span>
+                    <div class="type-col-lbl">read</div>
-                    <span>snippet</span>
+                    <button data-type="note" class="type-btn">
-                </button>
+                        <span class="type-glyph glyph-note">¶</span>
-                <button data-type="template" class="type-btn">
+                        <span class="type-name">note</span>
-                    <span class="type-glyph">◈</span>
+                        <span class="type-hint">markdown content</span>
-                    <span>template</span>
-                </button>
-                <button data-type="checklist" class="type-btn">
-                    <span class="type-glyph">☐</span>
-                    <span>checklist</span>
-                </button>
-                <button data-type="decision" class="type-btn">
-                    <span class="type-glyph">⚖</span>
-                    <span>decision</span>
                     </button>
                     <button data-type="link" class="type-btn">
-                    <span class="type-glyph">↗</span>
+                        <span class="type-glyph glyph-link">↗</span>
-                    <span>link</span>
+                        <span class="type-name">link</span>
+                        <span class="type-hint">reference URL</span>
                     </button>
+                    <button data-type="decision" class="type-btn">
+                        <span class="type-glyph glyph-decision">⚖</span>
+                        <span class="type-name">decision</span>
+                        <span class="type-hint">choice + rationale</span>
+                    </button>
+                </div>
+                <div class="type-col">
+                    <div class="type-col-lbl">grab</div>
+                    <button data-type="snippet" class="type-btn">
+                        <span class="type-glyph glyph-snippet">◆</span>
+                        <span class="type-name">snippet</span>
+                        <span class="type-hint">code, command, text</span>
+                    </button>
+                </div>
+                <div class="type-col">
+                    <div class="type-col-lbl">fill</div>
+                    <button data-type="template" class="type-btn">
+                        <span class="type-glyph glyph-template">◈</span>
+                        <span class="type-name">template</span>
+                        <span class="type-hint">fillable ${slot}s</span>
+                    </button>
+                    <button data-type="checklist" class="type-btn">
+                        <span class="type-glyph glyph-checklist">☐</span>
+                        <span class="type-name">checklist</span>
+                        <span class="type-hint">step-by-step</span>
+                    </button>
+                </div>
             </div>
             <button class="modal-close">esc to cancel</button>
         </div>
@@ -71,6 +97,7 @@
         </div>
     </div>
 
+    <script src="https://cdn.jsdelivr.net/npm/marked@15/marked.min.js"></script>
     <script src="/app.js"></script>
 </body>
 </html>