From e8603f3ffacd0b0367d13f9129ab2d4d5d308185 Mon Sep 17 00:00:00 2001
From: Than Tibbetts <than@broomfitters.com>
Date: Tue, 29 Sep 2026 14:23:30 -0400
Subject: [PATCH 01/11] Act on board items from the viewer: tick, answer, send
 to Done

The viewer selects an item with ] and [, then writes one line change back:
x ticks a checklist item, 1-9/y/n/d answer an Ask: prompt, and d moves an
item to Done. M turns on mouse mode for clicks. Writes locate the item by
exact text and swap the file in by rename. sidecar diff names a tick or an
answer so the agent reads the decision on its next turn.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 README.md                                     |   3 +-
 board.go                                      |  10 +-
 ...6-09-29-interactive-line-updates-design.md |  37 +++
 edit.go                                       | 237 ++++++++++++++++
 edit_test.go                                  | 165 ++++++++++++
 interact.go                                   | 253 ++++++++++++++++++
 interact_test.go                              | 140 ++++++++++
 main.go                                       |   5 +
 sections.go                                   |   1 +
 semdiff.go                                    |  23 +-
 ui.go                                         |  55 +++-
 11 files changed, 924 insertions(+), 5 deletions(-)
 create mode 100644 docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
 create mode 100644 edit.go
 create mode 100644 edit_test.go
 create mode 100644 interact.go
 create mode 100644 interact_test.go

diff --git a/README.md b/README.md
index ca20fcc..72308fb 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,8 @@ Boards are per-directory. `sidecar init` refuses a board that is a symlink — t
 ## What it does
 
 - Renders Markdown with [glamour] and re-renders the moment the file changes. Sidecar watches the parent directory with fsnotify and a 100-millisecond debounce, so it handles atomic rename-swaps, deletes, and recreates — and waits quietly when the file doesn’t exist yet.
-- Scrolls with `j` and `k`, the arrow keys, `PgUp` and `PgDn`, and `g` and `G` for top and bottom. Sidecar keeps your scroll position across reloads. It doesn’t capture the mouse, so your terminal’s text selection and clickable links keep working.
+- Scrolls with `j` and `k`, the arrow keys, `PgUp` and `PgDn`, and `g` and `G` for top and bottom. Sidecar keeps your scroll position across reloads. It doesn’t capture the mouse by default, so your terminal’s text selection and clickable links keep working.
+- Acts on items from the keyboard. `]` and `[` select an item; `x` ticks a `- [ ]` item, `1`–`9` (or `y`, `n`, `d`) answer an item's `Ask: yes | no` line, and `d` sends any other item to Done. Each action writes one line change to the board, and the agent's next-turn hook reports it — `edited 🧠: "Ship it" — ticked`, or `— answered "no"`. `M` turns on mouse mode for clicks; press it again to get native text selection back.
 - `Tab` and `Shift+Tab` move a cursor between sections; `Enter` or `Space` collapses or expands the section under it. `✅ Done` and `📦 Shipped` start collapsed — every heading shows its item count, e.g. `✅ Done (12)`.
 - Reloads on demand with `r`, and quits with `q`.
 - Re-renders when you resize the terminal, at the pane width minus 2. It never renders wider than the pane.
diff --git a/board.go b/board.go
index e76be7d..d2fde92 100644
--- a/board.go
+++ b/board.go
@@ -113,9 +113,17 @@ func parseBoard(raw string) (Board, bool) {
 	return b, len(b.Sections) > 0
 }
 
-// normalizeItem strips the bullet and collapses whitespace on the first line.
+// normalizeItem strips the bullet and task-list marker and collapses whitespace on the first line.
 func normalizeItem(line string) string {
 	s := strings.TrimSpace(line)
 	s = strings.TrimPrefix(s, "- ")
+	// A task-list marker is state, not identity: ticking an item must read
+	// as the same item edited, not one removed and another added.
+	for _, m := range []string{"[ ] ", "[x] ", "[X] "} {
+		if strings.HasPrefix(s, m) {
+			s = strings.TrimPrefix(s, m)
+			break
+		}
+	}
 	return strings.Join(strings.Fields(s), " ")
 }
diff --git a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
new file mode 100644
index 0000000..f14838d
--- /dev/null
+++ b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
@@ -0,0 +1,37 @@
+# Interactive line updates
+
+The viewer gains one write path: the human acts on a board item and sidecar writes that one line change back. The per-turn hook already diffs the board, so the agent reads the decision on its next turn.
+
+## Intent
+
+- The human ticks a checklist item, answers a yes/no/and/or/done prompt, or sends an item to ✅ Done without typing in chat.
+- Keyboard first. Native text selection and clickable links stay the default; mouse clicks work only while mouse mode (`M`) is on.
+
+## Board syntax
+
+Plain markdown, nothing new to parse beyond two line prefixes.
+
+- `- [ ]` / `- [x]` — a checklist item. `x` toggles it.
+- `  Ask: yes | no | done` — an indented line under an item; options are separated by `|` and can be any words (`and`, `or`, …).
+- `  Answer: no` — written directly under the `Ask:` line. A new answer replaces the old one, so an item carries at most one.
+
+## Keys
+
+`]` / `[` select the next or previous item. With one selected: `x` ticks; `1`–`9` answer by position; `y` / `n` / `d` answer `yes` / `no` / `done` when offered; `d` otherwise moves the item to ✅ Done; `esc` deselects. `M` toggles mouse mode: a click selects an item, a click on its box ticks it.
+
+## Writes
+
+- `editItem` re-reads the file, locates the item by section label and exact item text, applies a pure text transform, and swaps the file in by rename, keeping its mode.
+- An edit by the agent elsewhere in the file survives. If the item itself changed since the viewer rendered it, nothing is written and the status bar says so.
+- Only three mutations exist: toggle a checkbox, set an answer, move an item to Done. Free-form editing is out of scope.
+
+## Agent side
+
+- A task-list marker is state, not identity, so `normalizeItem` strips it: ticking reads as `edited`, not remove-plus-add.
+- `sidecar diff` appends `— ticked`, `— unticked`, or `— answered "x"` to the edited line.
+- The CLAUDE.md note teaches the `Ask:` / `Answer:` convention through `entryStyleRules`.
+
+## Known limits
+
+- The item cursor maps items to rendered lines by their column-0 marker (`•`, `□`, `✓`). A section whose rendered count differs from the parsed count, such as a collapsed section, is skipped rather than mis-selected.
+- The rename swap leaves a small window in which a concurrent write by the agent to the same file is lost; the exact-text match narrows it to the same item.
diff --git a/edit.go b/edit.go
new file mode 100644
index 0000000..c73b520
--- /dev/null
+++ b/edit.go
@@ -0,0 +1,237 @@
+// edit.go — the viewer's only writes to the board: tick a checklist item,
+// answer an Ask: prompt, or move an item to ✅ Done. Every edit is a pure
+// text transform on one item, located by section label and exact item text
+// in the file as it is on disk right now, so an unrelated edit by the agent
+// between render and keypress is preserved and a conflicting one is refused.
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+var errBoardChanged = errors.New("board changed under the cursor — nothing written")
+
+// checkboxPrefixes are the task-list markers on an item's first line.
+const (
+	unticked = "- [ ] "
+	ticked   = "- [x] "
+)
+
+// isCheckbox reports whether an item's first line is a task-list item.
+func isCheckbox(it BoardItem) bool {
+	first := firstLine(it.Raw)
+	return strings.HasPrefix(first, unticked) || strings.HasPrefix(strings.ToLower(first), ticked)
+}
+
+func firstLine(raw string) string {
+	first, _, _ := strings.Cut(raw, "\n")
+	return first
+}
+
+// toggleCheckbox flips "- [ ]" and "- [x]" on the item's first line.
+func toggleCheckbox(lines []string) ([]string, error) {
+	out := append([]string(nil), lines...)
+	switch {
+	case strings.HasPrefix(out[0], unticked):
+		out[0] = ticked + strings.TrimPrefix(out[0], unticked)
+	case strings.HasPrefix(strings.ToLower(out[0]), ticked):
+		out[0] = unticked + out[0][len(ticked):]
+	default:
+		return nil, errors.New("not a checklist item")
+	}
+	return out, nil
+}
+
+// askOptions returns the options of an item's "Ask:" line — "Ask: yes | no"
+// yields ["yes", "no"] — or nil when the item asks nothing.
+func askOptions(it BoardItem) []string {
+	_, rest, _ := strings.Cut(it.Raw, "\n")
+	for _, ln := range strings.Split(rest, "\n") {
+		if v, ok := strings.CutPrefix(strings.TrimSpace(ln), "Ask:"); ok {
+			var opts []string
+			for _, o := range strings.Split(v, "|") {
+				if o = strings.TrimSpace(o); o != "" {
+					opts = append(opts, o)
+				}
+			}
+			return opts
+		}
+	}
+	return nil
+}
+
+// answerOf returns the item's current "Answer:" value, "" when unanswered.
+func answerOf(it BoardItem) string {
+	_, rest, _ := strings.Cut(it.Raw, "\n")
+	for _, ln := range strings.Split(rest, "\n") {
+		if v, ok := strings.CutPrefix(strings.TrimSpace(ln), "Answer:"); ok {
+			return strings.TrimSpace(v)
+		}
+	}
+	return ""
+}
+
+// setAnswer writes "Answer: <option>" directly under the Ask: line,
+// replacing an earlier answer so the item never carries two.
+func setAnswer(lines []string, option string) ([]string, error) {
+	askAt := -1
+	for i, ln := range lines[1:] {
+		if strings.HasPrefix(strings.TrimSpace(ln), "Ask:") {
+			askAt = i + 1
+			break
+		}
+	}
+	if askAt < 0 {
+		return nil, errors.New("no Ask: line on this item")
+	}
+	indent := lines[askAt][:len(lines[askAt])-len(strings.TrimLeft(lines[askAt], " \t"))]
+	var out []string
+	for i, ln := range lines {
+		if i > 0 && strings.HasPrefix(strings.TrimSpace(ln), "Answer:") {
+			continue
+		}
+		out = append(out, ln)
+		if i == askAt {
+			out = append(out, indent+"Answer: "+option)
+		}
+	}
+	return out, nil
+}
+
+// moveItem returns raw with the item at (si, ii) moved to the end of the
+// section labeled target, replacing that section's "nothing yet" placeholder.
+func moveItem(raw string, b Board, si, ii int, target string) (string, error) {
+	ti := -1
+	for i, s := range b.Sections {
+		if s.Label == target {
+			ti = i
+		}
+	}
+	if ti < 0 {
+		return "", fmt.Errorf("no %q section", target)
+	}
+	if ti == si {
+		return "", errors.New("already there")
+	}
+	lines := strings.Split(raw, "\n")
+	it := b.Sections[si].Items[ii]
+	block := append([]string(nil), lines[it.StartLine:it.EndLine+1]...)
+
+	ts := b.Sections[ti]
+	skip := make([]bool, len(lines))
+	for i := it.StartLine; i <= it.EndLine; i++ {
+		skip[i] = true
+	}
+	at := ts.HeaderLine + 1 // insert before this original index
+	blankFirst := false
+	real := 0
+	for _, x := range ts.Items {
+		if x.Key == emptySectionPlaceholder {
+			for i := x.StartLine; i <= x.EndLine; i++ {
+				skip[i] = true
+			}
+			at = x.StartLine
+			continue
+		}
+		real++
+		at = x.EndLine + 1
+	}
+	if real == 0 && len(ts.Items) == 0 {
+		if at < len(lines) && strings.TrimSpace(lines[at]) == "" {
+			at++
+		} else {
+			blankFirst = true
+		}
+	}
+
+	var out []string
+	for i := 0; i <= len(lines); i++ {
+		if i == at {
+			if blankFirst {
+				out = append(out, "")
+			}
+			out = append(out, block...)
+			if blankFirst {
+				out = append(out, "")
+			}
+		}
+		if i < len(lines) && !skip[i] {
+			out = append(out, lines[i])
+		}
+	}
+	return strings.Join(out, "\n"), nil
+}
+
+// editItem re-reads the board, finds the item by section label and exact
+// text, and lets fn produce the new file content. errBoardChanged means the
+// item is gone or was edited since the viewer rendered it.
+func editItem(path, label, oldRaw string, fn func(raw string, b Board, si, ii int) (string, error)) error {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return err
+	}
+	raw := string(data)
+	b, ok := parseBoard(raw)
+	if !ok {
+		return errBoardChanged
+	}
+	for si, s := range b.Sections {
+		if s.Label != label {
+			continue
+		}
+		for ii, it := range s.Items {
+			if it.Raw == oldRaw {
+				next, err := fn(raw, b, si, ii)
+				if err != nil {
+					return err
+				}
+				return writeAtomic(path, next)
+			}
+		}
+	}
+	return errBoardChanged
+}
+
+// replaceLines is the common shape of tick and answer: swap one item's
+// lines for the transform of them.
+func replaceLines(t func([]string) ([]string, error)) func(string, Board, int, int) (string, error) {
+	return func(raw string, b Board, si, ii int) (string, error) {
+		it := b.Sections[si].Items[ii]
+		lines := strings.Split(raw, "\n")
+		repl, err := t(lines[it.StartLine : it.EndLine+1])
+		if err != nil {
+			return "", err
+		}
+		out := append(append(append([]string(nil), lines[:it.StartLine]...), repl...), lines[it.EndLine+1:]...)
+		return strings.Join(out, "\n"), nil
+	}
+}
+
+// writeAtomic swaps the file in via rename so a watcher or the agent never
+// reads a half-written board, keeping the original file mode.
+func writeAtomic(path, content string) error {
+	mode := os.FileMode(0o644)
+	if st, err := os.Stat(path); err == nil {
+		mode = st.Mode().Perm()
+	}
+	tmp, err := os.CreateTemp(filepath.Dir(path), ".sidecar-edit-*")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(tmp.Name())
+	if _, err := tmp.WriteString(content); err != nil {
+		tmp.Close()
+		return err
+	}
+	if err := tmp.Close(); err != nil {
+		return err
+	}
+	if err := os.Chmod(tmp.Name(), mode); err != nil {
+		return err
+	}
+	return os.Rename(tmp.Name(), path)
+}
diff --git a/edit_test.go b/edit_test.go
new file mode 100644
index 0000000..f9ea72a
--- /dev/null
+++ b/edit_test.go
@@ -0,0 +1,165 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const editBoard = `# Board
+
+## 🧠 Needs you
+
+- [ ] Ship it
+- Pick a path
+  Ask: yes | no | done
+  Next: answer
+
+## 🚧 In progress
+
+- ` + emptySectionPlaceholder + `
+
+## ✅ Done
+
+- old
+`
+
+func writeBoardFile(t *testing.T, body string) string {
+	t.Helper()
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	if err := os.WriteFile(p, []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	return p
+}
+
+func readFile(t *testing.T, p string) string {
+	t.Helper()
+	d, err := os.ReadFile(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return string(d)
+}
+
+func TestToggleCheckboxBothWays(t *testing.T) {
+	on, err := toggleCheckbox([]string{"- [ ] a", "  more"})
+	if err != nil || on[0] != "- [x] a" || on[1] != "  more" {
+		t.Fatalf("tick: %v %v", on, err)
+	}
+	off, _ := toggleCheckbox([]string{"- [X] a"})
+	if off[0] != "- [ ] a" {
+		t.Fatalf("untick: %v", off)
+	}
+	if _, err := toggleCheckbox([]string{"- plain"}); err == nil {
+		t.Fatal("plain bullet must not toggle")
+	}
+}
+
+func TestAskOptionsAndAnswer(t *testing.T) {
+	b, _ := parseBoard(editBoard)
+	it := b.Sections[0].Items[1]
+	if got := strings.Join(askOptions(it), ","); got != "yes,no,done" {
+		t.Fatalf("options %q", got)
+	}
+	lines := strings.Split(it.Raw, "\n")
+	a, err := setAnswer(lines, "no")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if a[2] != "  Answer: no" || len(a) != 4 {
+		t.Fatalf("answer placement: %q", a)
+	}
+	a2, _ := setAnswer(a, "yes")
+	if len(a2) != 4 || a2[2] != "  Answer: yes" {
+		t.Fatalf("re-answer must replace: %q", a2)
+	}
+}
+
+func TestEditItemWritesOnlyThatItem(t *testing.T) {
+	p := writeBoardFile(t, editBoard)
+	b, _ := parseBoard(editBoard)
+	it := b.Sections[0].Items[0]
+	if err := editItem(p, "🧠 Needs you", it.Raw, replaceLines(toggleCheckbox)); err != nil {
+		t.Fatal(err)
+	}
+	want := strings.Replace(editBoard, "- [ ] Ship it", "- [x] Ship it", 1)
+	if got := readFile(t, p); got != want {
+		t.Fatalf("got:\n%s\nwant:\n%s", got, want)
+	}
+}
+
+func TestEditItemRefusesWhenItemChanged(t *testing.T) {
+	p := writeBoardFile(t, strings.Replace(editBoard, "Ship it", "Ship it now", 1))
+	b, _ := parseBoard(editBoard)
+	err := editItem(p, "🧠 Needs you", b.Sections[0].Items[0].Raw, replaceLines(toggleCheckbox))
+	if err != errBoardChanged {
+		t.Fatalf("want errBoardChanged, got %v", err)
+	}
+}
+
+func TestEditItemKeepsConcurrentEditsElsewhere(t *testing.T) {
+	p := writeBoardFile(t, editBoard+"- added by agent\n")
+	b, _ := parseBoard(editBoard)
+	if err := editItem(p, "🧠 Needs you", b.Sections[0].Items[0].Raw, replaceLines(toggleCheckbox)); err != nil {
+		t.Fatal(err)
+	}
+	if got := readFile(t, p); !strings.Contains(got, "- added by agent") || !strings.Contains(got, "- [x] Ship it") {
+		t.Fatalf("lost an edit:\n%s", got)
+	}
+}
+
+func TestMoveItemIntoPlaceholderSection(t *testing.T) {
+	b, _ := parseBoard(editBoard)
+	got, err := moveItem(editBoard, b, 0, 1, "🚧 In progress")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(got, emptySectionPlaceholder) {
+		t.Fatalf("placeholder survived:\n%s", got)
+	}
+	b2, _ := parseBoard(got)
+	if len(b2.Sections[0].Items) != 1 || !strings.HasPrefix(b2.Sections[1].Items[0].Raw, "- Pick a path\n  Ask:") {
+		t.Fatalf("bad move:\n%s", got)
+	}
+}
+
+func TestMoveItemAppendsAfterLastItem(t *testing.T) {
+	b, _ := parseBoard(editBoard)
+	got, err := moveItem(editBoard, b, 0, 0, "✅ Done")
+	if err != nil {
+		t.Fatal(err)
+	}
+	b2, _ := parseBoard(got)
+	done := b2.Sections[2].Items
+	if len(done) != 2 || done[0].Key != "old" || done[1].Key != "Ship it" {
+		t.Fatalf("bad move:\n%s", got)
+	}
+}
+
+func TestMoveItemIntoTrulyEmptySection(t *testing.T) {
+	raw := "## A\n\n- x\n\n## B\n\n## C\n\n- z\n"
+	b, _ := parseBoard(raw)
+	got, err := moveItem(raw, b, 0, 0, "B")
+	if err != nil {
+		t.Fatal(err)
+	}
+	b2, _ := parseBoard(got)
+	if len(b2.Sections[1].Items) != 1 || b2.Sections[1].Items[0].Key != "x" || len(b2.Sections[2].Items) != 1 {
+		t.Fatalf("bad move:\n%s", got)
+	}
+}
+
+func TestDiffNamesTickAndAnswer(t *testing.T) {
+	old := "## 🧠 Needs you\n\n- [ ] Ship it\n- Pick\n  Ask: yes | no\n"
+	next := "## 🧠 Needs you\n\n- [x] Ship it\n- Pick\n  Ask: yes | no\n  Answer: no\n"
+	ob, _ := parseBoard(old)
+	nb, _ := parseBoard(next)
+	got := strings.Join(semanticDiff(ob, nb), "\n")
+	for _, want := range []string{`edited 🧠: "Ship it" — ticked`, `edited 🧠: "Pick" — answered "no"`} {
+		if !strings.Contains(got, want) {
+			t.Fatalf("missing %q in:\n%s", want, got)
+		}
+	}
+}
diff --git a/interact.go b/interact.go
new file mode 100644
index 0000000..5c14bf8
--- /dev/null
+++ b/interact.go
@@ -0,0 +1,253 @@
+// interact.go — the viewer's item cursor: pick a board item, then tick it,
+// answer its Ask: prompt, or send it to ✅ Done. Keyboard-first; mouse
+// clicks work only while mouse mode (M) is on, so native text selection and
+// clickable links stay the default.
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+// itemStartLines maps each board item to the rendered line it starts on: a
+// top-level "• ", "□ ", or "✓ " line at column 0 between a section's header
+// and the next. A section whose rendered count disagrees with the parsed
+// count (collapsed, or a shape the renderer lays out differently) maps to
+// nil, so the cursor skips it rather than land on the wrong line.
+func itemStartLines(lines []string, headers []int, board Board) [][]int {
+	out := make([][]int, len(board.Sections))
+	if len(headers) != len(board.Sections) {
+		return out
+	}
+	for si := range board.Sections {
+		end := len(lines)
+		if si+1 < len(headers) {
+			end = headers[si+1]
+		}
+		var starts []int
+		for i := headers[si] + 1; i < end; i++ {
+			t := stripANSI(lines[i])
+			if strings.HasPrefix(t, "• ") || strings.HasPrefix(t, "□ ") || strings.HasPrefix(t, "✓ ") {
+				starts = append(starts, i)
+			}
+		}
+		if len(starts) == len(board.Sections[si].Items) {
+			out[si] = starts
+		}
+	}
+	return out
+}
+
+// applyItemHighlight tints the selected item's rendered lines.
+func applyItemHighlight(display string, starts [][]int, si, ii, total, width int) string {
+	if si < 0 || si >= len(starts) || ii < 0 || ii >= len(starts[si]) {
+		return display
+	}
+	lines := strings.Split(display, "\n")
+	from := starts[si][ii]
+	to := from + 1
+	if ii+1 < len(starts[si]) {
+		to = starts[si][ii+1]
+	} else {
+		for to < len(lines) && strings.TrimSpace(stripANSI(lines[to])) != "" {
+			to++
+		}
+	}
+	for i := from; i < to && i < len(lines); i++ {
+		if strings.TrimSpace(stripANSI(lines[i])) != "" {
+			lines[i] = applyLineBg(lines[i], colorCursorBg, width)
+		}
+	}
+	return strings.Join(lines, "\n")
+}
+
+func (m model) selected() (BoardItem, string, bool) {
+	if m.itemSec < 0 || m.itemSec >= len(m.board.Sections) {
+		return BoardItem{}, "", false
+	}
+	s := m.board.Sections[m.itemSec]
+	if m.itemIdx < 0 || m.itemIdx >= len(s.Items) {
+		return BoardItem{}, "", false
+	}
+	return s.Items[m.itemIdx], s.Label, true
+}
+
+// moveItemCursor steps to the next (+1) or previous (-1) selectable item,
+// wrapping, and scrolls it into view.
+func (m *model) moveItemCursor(delta int) {
+	type pos struct{ s, i int }
+	var all []pos
+	cur := -1
+	for si, starts := range m.itemStarts {
+		for ii := range starts {
+			if m.board.Sections[si].Items[ii].Key == emptySectionPlaceholder {
+				continue
+			}
+			if si == m.itemSec && ii == m.itemIdx {
+				cur = len(all)
+			}
+			all = append(all, pos{si, ii})
+		}
+	}
+	if len(all) == 0 {
+		return
+	}
+	next := 0
+	switch {
+	case cur >= 0:
+		next = ((cur+delta)%len(all) + len(all)) % len(all)
+	case delta < 0:
+		next = len(all) - 1
+	}
+	m.itemSec, m.itemIdx = all[next].s, all[next].i
+	m.cursor = m.itemSec
+	m.recompose()
+	m.scrollTo(m.itemStarts[m.itemSec][m.itemIdx])
+}
+
+func (m *model) clearItemCursor() {
+	m.itemSec, m.itemIdx = -1, -1
+	m.recompose()
+}
+
+// scrollTo brings a rendered line into view with a 1-line margin.
+func (m *model) scrollTo(target int) {
+	const margin = 1
+	top, bottom := m.vp.YOffset, m.vp.YOffset+m.vp.Height-1
+	switch {
+	case target < top+margin:
+		m.vp.SetYOffset(max(0, target-margin))
+	case target > bottom-margin:
+		m.vp.SetYOffset(target - m.vp.Height + 1 + margin)
+	}
+}
+
+// itemKey handles a keypress while an item is selected. It reports whether
+// the key was consumed.
+func (m *model) itemKey(key string) bool {
+	it, label, ok := m.selected()
+	if !ok {
+		return false
+	}
+	opts := askOptions(it)
+	switch {
+	case key == "esc":
+		m.clearItemCursor()
+		return true
+	case key == "x" && isCheckbox(it):
+		m.apply(label, it, replaceLines(toggleCheckbox), "")
+		return true
+	case len(opts) > 0 && optionForKey(key, opts) != "":
+		choice := optionForKey(key, opts)
+		m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, choice) }), "answered "+choice)
+		return true
+	case key == "d":
+		m.apply(label, it, func(raw string, b Board, si, ii int) (string, error) {
+			return moveItem(raw, b, si, ii, doneLabel(b))
+		}, "moved to Done")
+		m.itemSec, m.itemIdx = -1, -1
+		return true
+	}
+	return false
+}
+
+// optionForKey picks an Ask: option: a digit selects by position; y, n, and
+// d select "yes", "no", and "done" when the prompt offers them.
+func optionForKey(key string, opts []string) string {
+	if len(key) == 1 && key[0] >= '1' && key[0] <= '9' {
+		if n := int(key[0] - '1'); n < len(opts) {
+			return opts[n]
+		}
+		return ""
+	}
+	want := map[string]string{"y": "yes", "n": "no", "d": "done"}[key]
+	for _, o := range opts {
+		if want != "" && strings.EqualFold(o, want) {
+			return o
+		}
+	}
+	return ""
+}
+
+func doneLabel(b Board) string {
+	for _, s := range b.Sections {
+		if strings.HasSuffix(s.Label, "Done") {
+			return s.Label
+		}
+	}
+	return "✅ Done"
+}
+
+// apply writes one edit, then reloads so the pane shows the file as it now
+// is. A refused or failed write surfaces in the status bar.
+func (m *model) apply(label string, it BoardItem, fn func(string, Board, int, int) (string, error), note string) {
+	if err := editItem(m.path, label, it.Raw, fn); err != nil {
+		m.notice = err.Error()
+		if err == errBoardChanged {
+			m.reload(true)
+		}
+		return
+	}
+	m.notice = note
+	m.reload(true)
+}
+
+// hint is the status-bar line shown while an item is selected.
+func (m model) hint() string {
+	it, _, ok := m.selected()
+	if !ok {
+		return ""
+	}
+	parts := []string{"[ ] prev  ] next"}
+	if isCheckbox(it) {
+		parts = append(parts, "x tick")
+	}
+	if opts := askOptions(it); len(opts) > 0 {
+		var o []string
+		for i, v := range opts {
+			o = append(o, fmt.Sprintf("%d %s", i+1, v))
+		}
+		parts = append(parts, strings.Join(o, "  "))
+	}
+	parts = append(parts, "d done", "esc")
+	return strings.Join(parts, " · ")
+}
+
+// mouseClick selects the item under a left click and, in the checkbox
+// gutter, ticks it. Only wired while mouse mode is on.
+func (m *model) mouseClick(x, y int) {
+	line := y + m.vp.YOffset
+	for si, starts := range m.itemStarts {
+		for ii, start := range starts {
+			end := start + 1
+			if ii+1 < len(starts) {
+				end = starts[ii+1]
+			} else {
+				for end < len(m.renderedLines) && strings.TrimSpace(stripANSI(m.renderedLines[end])) != "" {
+					end++
+				}
+			}
+			if line < start || line >= end || m.board.Sections[si].Items[ii].Key == emptySectionPlaceholder {
+				continue
+			}
+			m.itemSec, m.itemIdx, m.cursor = si, ii, si
+			m.recompose()
+			if it, label, _ := m.selected(); x <= 1 && line == start && isCheckbox(it) {
+				m.apply(label, it, replaceLines(toggleCheckbox), "")
+			}
+			return
+		}
+	}
+}
+
+func (m *model) toggleMouse() tea.Cmd {
+	m.mouse = !m.mouse
+	if m.mouse {
+		m.notice = "mouse on — click an item, click its box to tick (M to release)"
+		return tea.EnableMouseCellMotion
+	}
+	m.notice = "mouse off — native selection restored"
+	return tea.DisableMouse
+}
diff --git a/interact_test.go b/interact_test.go
new file mode 100644
index 0000000..1b263e5
--- /dev/null
+++ b/interact_test.go
@@ -0,0 +1,140 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func press(t *testing.T, m model, keys ...string) model {
+	t.Helper()
+	for _, k := range keys {
+		msg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(k)}
+		if k == "esc" {
+			msg = tea.KeyMsg{Type: tea.KeyEsc}
+		}
+		next, _ := m.Update(msg)
+		m = next.(model)
+	}
+	return m
+}
+
+func interactModel(t *testing.T) (model, string) {
+	t.Helper()
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, editBoard)
+	return testModel(t, p), p
+}
+
+func TestItemStartLinesMapEveryItem(t *testing.T) {
+	m, _ := interactModel(t)
+	got := 0
+	for si, starts := range m.itemStarts {
+		if len(starts) != len(m.board.Sections[si].Items) && !m.collapsed[m.board.Sections[si].Label] {
+			t.Fatalf("section %d mapped %d of %d", si, len(starts), len(m.board.Sections[si].Items))
+		}
+		got += len(starts)
+	}
+	if got == 0 {
+		t.Fatal("no items mapped")
+	}
+}
+
+func TestTickItemFromKeyboard(t *testing.T) {
+	m, p := interactModel(t)
+	m = press(t, m, "]", "x")
+	if got := readFile(t, p); !strings.Contains(got, "- [x] Ship it") {
+		t.Fatalf("not ticked:\n%s", got)
+	}
+	m = press(t, m, "x")
+	if got := readFile(t, p); !strings.Contains(got, "- [ ] Ship it") {
+		t.Fatalf("not unticked:\n%s", got)
+	}
+}
+
+func TestAnswerAskFromKeyboard(t *testing.T) {
+	m, p := interactModel(t)
+	m = press(t, m, "]", "]", "n")
+	if got := readFile(t, p); !strings.Contains(got, "  Ask: yes | no | done\n  Answer: no\n") {
+		t.Fatalf("not answered:\n%s", got)
+	}
+	press(t, m, "1")
+	if got := readFile(t, p); strings.Count(got, "Answer:") != 1 || !strings.Contains(got, "Answer: yes") {
+		t.Fatalf("answer not replaced:\n%s", got)
+	}
+}
+
+func TestDoneKeyOnAskAnswersDoneNotMove(t *testing.T) {
+	m, p := interactModel(t)
+	press(t, m, "]", "]", "d")
+	got := readFile(t, p)
+	if !strings.Contains(got, "Answer: done") || strings.Count(got, "Pick a path") != 1 {
+		t.Fatalf("d on a prompt offering done should answer it:\n%s", got)
+	}
+	b, _ := parseBoard(got)
+	if len(b.Sections[2].Items) != 1 {
+		t.Fatalf("item must not move:\n%s", got)
+	}
+}
+
+func TestDoneKeyMovesPlainItem(t *testing.T) {
+	m, p := interactModel(t)
+	m = press(t, m, "]", "d")
+	b, _ := parseBoard(readFile(t, p))
+	if len(b.Sections[2].Items) != 2 || b.Sections[0].Items[0].Key != "Pick a path" {
+		t.Fatalf("not moved:\n%s", readFile(t, p))
+	}
+	if m.itemSec != -1 {
+		t.Fatal("cursor should clear after a move")
+	}
+}
+
+func TestEditRefusedWhenAgentChangedItem(t *testing.T) {
+	m, p := interactModel(t)
+	m = press(t, m, "]")
+	writeFile(t, p, strings.Replace(editBoard, "Ship it", "Ship it now", 1))
+	m = press(t, m, "x")
+	if !strings.Contains(m.notice, "changed") {
+		t.Fatalf("notice %q", m.notice)
+	}
+	if got := readFile(t, p); strings.Contains(got, "[x]") {
+		t.Fatalf("stale edit was written:\n%s", got)
+	}
+}
+
+func TestEscClearsItemCursor(t *testing.T) {
+	m, _ := interactModel(t)
+	m = press(t, m, "]", "esc")
+	if m.itemSec != -1 {
+		t.Fatal("esc should clear")
+	}
+}
+
+func TestMouseClickTicksBoxOnlyInMouseMode(t *testing.T) {
+	m, p := interactModel(t)
+	line := m.itemStarts[0][0]
+	click := tea.MouseMsg{X: 0, Y: line - m.vp.YOffset, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft}
+	next, _ := m.Update(click)
+	m = next.(model)
+	if strings.Contains(readFile(t, p), "[x]") {
+		t.Fatal("click must be ignored while mouse mode is off")
+	}
+	m = press(t, m, "M")
+	next, _ = m.Update(click)
+	if !strings.Contains(readFile(t, p), "- [x] Ship it") {
+		t.Fatal("click on the box should tick in mouse mode")
+	}
+	_ = next
+}
+
+func TestEditPreservesFileMode(t *testing.T) {
+	m, p := interactModel(t)
+	os.Chmod(p, 0o600)
+	press(t, m, "]", "x")
+	if st, _ := os.Stat(p); st.Mode().Perm() != 0o600 {
+		t.Fatalf("mode %v", st.Mode().Perm())
+	}
+}
diff --git a/main.go b/main.go
index 8eca149..300cbfa 100644
--- a/main.go
+++ b/main.go
@@ -34,6 +34,11 @@ keys:  j/k, arrows, PgUp/PgDn                scroll
        g / G                                top / bottom
        tab / shift+tab                      move between sections
        enter / space                        collapse / expand section
+       ] / [                                select next / previous item
+         x  tick a - [ ] item               1-9  answer an "Ask:" option
+         y / n / d  answer yes / no / done  d    otherwise move item to Done
+         esc  deselect
+       M                                    mouse mode: click an item, click its box
        r                                    force reload
        q                                    quit
 
diff --git a/sections.go b/sections.go
index 68101f4..79f7934 100644
--- a/sections.go
+++ b/sections.go
@@ -159,6 +159,7 @@ func entryStyleRules(sections []Section, bullet string) string {
 		}
 		b.WriteString(" until it needs a decision, and then the `Next:` line asks for that decision.\n")
 	}
+	b.WriteString("\nAn entry asks a quick question with an indented `Ask: yes | no` line — options separated by `|`, any words. The human answers in the viewer, and an `Answer:` line appears under it; read it on your next turn and act on it. A `- [ ]` checklist item works the same way — the human ticks it, and it reads `- [x]`.\n")
 	return b.String()
 }
 
diff --git a/semdiff.go b/semdiff.go
index d823d3c..b67bb57 100644
--- a/semdiff.go
+++ b/semdiff.go
@@ -68,7 +68,7 @@ func semanticDiff(old, new Board) []string {
 		case ot != nt:
 			moved = append(moved, fmt.Sprintf("moved %s→%s: %q", ot, nt, title(n.item.Key)))
 		case o.item.Raw != n.item.Raw:
-			edited = append(edited, fmt.Sprintf("edited %s: %q", nt, title(n.item.Key)))
+			edited = append(edited, fmt.Sprintf("edited %s: %q%s", nt, title(n.item.Key), humanChange(o.item, n.item)))
 		}
 	}
 
@@ -361,3 +361,24 @@ func hunkHeader(o, dels, n, adds int) string {
 	}
 	return fmt.Sprintf("@@ -%s +%s @@", side(o, dels), side(n, adds))
 }
+
+// humanChange names the reader-facing state changes the viewer writes — a
+// ticked box or an answered prompt — so the agent sees the decision in the
+// diff itself, not just that the item changed.
+func humanChange(old, new BoardItem) string {
+	var out string
+	switch ot, nt := isTicked(old), isTicked(new); {
+	case isCheckbox(new) && ot != nt && nt:
+		out += " — ticked"
+	case isCheckbox(new) && ot != nt:
+		out += " — unticked"
+	}
+	if a := answerOf(new); a != answerOf(old) && a != "" {
+		out += fmt.Sprintf(" — answered %q", a)
+	}
+	return out
+}
+
+func isTicked(it BoardItem) bool {
+	return strings.HasPrefix(strings.ToLower(firstLine(it.Raw)), ticked)
+}
diff --git a/ui.go b/ui.go
index 4f9485a..7b502c7 100644
--- a/ui.go
+++ b/ui.go
@@ -82,10 +82,18 @@ type model struct {
 	collapsed   map[string]bool
 	cursor      int
 	headerLines []int
+
+	// Interactive updates (interact.go). itemSec/itemIdx select a board
+	// item, -1 for none; itemStarts maps items to rendered lines. notice is
+	// a one-shot status-bar message; mouse is mouse mode (M).
+	itemSec, itemIdx int
+	itemStarts       [][]int
+	notice           string
+	mouse            bool
 }
 
 func newModel(path string, noFlash bool) model {
-	return model{path: path, noFlash: noFlash, collapsed: map[string]bool{}, cursor: -1}
+	return model{path: path, noFlash: noFlash, collapsed: map[string]bool{}, cursor: -1, itemSec: -1, itemIdx: -1}
 }
 
 func (m model) Init() tea.Cmd {
@@ -98,10 +106,30 @@ func tick() tea.Cmd {
 
 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
+	case tea.MouseMsg:
+		if m.mouse && msg.Action == tea.MouseActionPress && msg.Button == tea.MouseButtonLeft {
+			m.mouseClick(msg.X, msg.Y)
+			return m, nil
+		}
+
 	case tea.KeyMsg:
+		m.notice = ""
+		if m.itemKey(msg.String()) {
+			return m, nil
+		}
 		switch msg.String() {
 		case "q", "ctrl+c":
 			return m, tea.Quit
+		case "]":
+			m.moveItemCursor(1)
+			return m, nil
+		case "[":
+			m.moveItemCursor(-1)
+			return m, nil
+		case "M":
+			return m, m.toggleMouse()
+		case "esc":
+			return m, nil
 		case "r":
 			if m.reload(true) {
 				m.flashGen++
@@ -295,6 +323,8 @@ func (m *model) reload(force bool) (changed bool) {
 	}
 	lines := strings.Split(rendered, "\n")
 	m.headerLines = sectionHeaderLines(lines)
+	m.itemStarts = itemStartLines(lines, m.headerLines, m.board)
+	m.fixItemCursor()
 
 	var changedMap map[int]bool
 	if m.hasBaseline {
@@ -327,7 +357,8 @@ func (m *model) reload(force bool) (changed bool) {
 // (applyCursorHighlight) — at the current flash and cursor state.
 func (m *model) compose() string {
 	display := composeMarked(m.renderedLines, m.changed, m.lineFlash && !m.noFlash, m.renderWidth())
-	return applyCursorHighlight(display, m.headerLines, m.cursor, m.renderWidth())
+	display = applyCursorHighlight(display, m.headerLines, m.cursor, m.renderWidth())
+	return applyItemHighlight(display, m.itemStarts, m.itemSec, m.itemIdx, 0, m.renderWidth())
 }
 
 // recompose re-renders the cached lines for the current flash state without
@@ -357,6 +388,8 @@ func (m *model) rerenderCollapse() {
 	}
 	m.renderedLines = strings.Split(rendered, "\n")
 	m.headerLines = sectionHeaderLines(m.renderedLines)
+	m.itemStarts = itemStartLines(m.renderedLines, m.headerLines, m.board)
+	m.fixItemCursor()
 	m.changed = nil
 	offset := m.vp.YOffset
 	m.vp.SetContent(m.compose())
@@ -478,6 +511,12 @@ func (m model) statusBar() string {
 
 	left := " 🚗 " + name + " "
 	info := "· " + updated
+	switch h := m.hint(); {
+	case m.notice != "":
+		info = "· " + m.notice
+	case h != "":
+		info = "· " + h
+	}
 	pct := fmt.Sprintf(" %3.0f%% ", m.vp.ScrollPercent()*100)
 
 	pad := m.width - visibleWidth(left) - visibleWidth(info) - visibleWidth(pct)
@@ -526,3 +565,15 @@ func humanSince(d time.Duration) string {
 		return fmt.Sprintf("%dd", int(d.Hours()/24))
 	}
 }
+
+// fixItemCursor drops the item selection when the file changed under it —
+// the item is gone, or its section can no longer be mapped to rendered
+// lines — rather than leave the tint on an unrelated line.
+func (m *model) fixItemCursor() {
+	if m.itemSec < 0 {
+		return
+	}
+	if m.itemSec >= len(m.itemStarts) || m.itemIdx >= len(m.itemStarts[m.itemSec]) {
+		m.itemSec, m.itemIdx = -1, -1
+	}
+}

From f23e38db03030daf25b934120a961d7ebe4bb8d4 Mon Sep 17 00:00:00 2001
From: Than Tibbetts <than@broomfitters.com>
Date: Tue, 29 Sep 2026 14:26:48 -0400
Subject: [PATCH 02/11] Guard status-bar clicks and close the Ask/Answer loop
 in the note

A click on the status bar row no longer maps to content below the fold.
The note now says what the agent does with an answer, and lists Ask: among
the lines an entry may carry.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 interact.go      |  5 ++++-
 interact_test.go | 12 ++++++++++++
 sections.go      |  3 ++-
 3 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/interact.go b/interact.go
index 5c14bf8..58743b9 100644
--- a/interact.go
+++ b/interact.go
@@ -200,7 +200,7 @@ func (m model) hint() string {
 	if !ok {
 		return ""
 	}
-	parts := []string{"[ ] prev  ] next"}
+	parts := []string{"[ prev · ] next"}
 	if isCheckbox(it) {
 		parts = append(parts, "x tick")
 	}
@@ -218,6 +218,9 @@ func (m model) hint() string {
 // mouseClick selects the item under a left click and, in the checkbox
 // gutter, ticks it. Only wired while mouse mode is on.
 func (m *model) mouseClick(x, y int) {
+	if y < 0 || y >= m.vp.Height {
+		return // the status bar row is not content
+	}
 	line := y + m.vp.YOffset
 	for si, starts := range m.itemStarts {
 		for ii, start := range starts {
diff --git a/interact_test.go b/interact_test.go
index 1b263e5..cef4f17 100644
--- a/interact_test.go
+++ b/interact_test.go
@@ -138,3 +138,15 @@ func TestEditPreservesFileMode(t *testing.T) {
 		t.Fatalf("mode %v", st.Mode().Perm())
 	}
 }
+
+func TestMouseClickOnStatusBarRowIgnored(t *testing.T) {
+	m, p := interactModel(t)
+	m = press(t, m, "M")
+	m.vp.SetYOffset(0)
+	// The status bar row sits at y == viewport height; it must not map to
+	// content below the fold even when a checkbox starts on that line.
+	m.mouseClick(0, m.vp.Height)
+	if strings.Contains(readFile(t, p), "[x]") || m.itemSec != -1 {
+		t.Fatal("status bar click acted on an item")
+	}
+}
diff --git a/sections.go b/sections.go
index 79f7934..0c0a844 100644
--- a/sections.go
+++ b/sections.go
@@ -146,6 +146,7 @@ func entryStyleRules(sections []Section, bullet string) string {
 		"two sentences of detail — more belongs in the PR or issue you link",
 		"bare URLs, each on its own line",
 		"one `Next:` line naming the single next action",
+		"optionally an indented `Ask:` line with options separated by `|`, which the human answers with an `Answer:` line",
 		"entry text on one line — never hard-wrap; the viewer wraps to the pane and source newlines become visible breaks",
 	} {
 		b.WriteString(bullet + r + "\n")
@@ -159,7 +160,7 @@ func entryStyleRules(sections []Section, bullet string) string {
 		}
 		b.WriteString(" until it needs a decision, and then the `Next:` line asks for that decision.\n")
 	}
-	b.WriteString("\nAn entry asks a quick question with an indented `Ask: yes | no` line — options separated by `|`, any words. The human answers in the viewer, and an `Answer:` line appears under it; read it on your next turn and act on it. A `- [ ]` checklist item works the same way — the human ticks it, and it reads `- [x]`.\n")
+	b.WriteString("\nAn entry asks a quick question with an indented `Ask: yes | no` line — options separated by `|`, any words. The human answers in the viewer, and an `Answer:` line appears under it; read it on your next turn, act on it, then move the item out of its section or drop the `Ask:` and `Answer:` pair so it stops asking. A `- [ ]` checklist item works the same way — the human ticks it, and it reads `- [x]`.\n")
 	return b.String()
 }
 

From a5e347d026cde9276893b1f8eb11b7c4d44d3d21 Mon Sep 17 00:00:00 2001
From: Than Tibbetts <than@broomfitters.com>
Date: Tue, 29 Sep 2026 14:44:03 -0400
Subject: [PATCH 03/11] Let the human answer in their own words and find open
 questions fast

a opens a free-text answer in the status bar for any item with an Ask: line;
an Ask: with no options is an open question. } and { jump between unanswered
questions, and the status bar counts how many are waiting.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 README.md                                     |   2 +-
 ...6-09-29-interactive-line-updates-design.md |   7 +-
 edit.go                                       |  27 ++++
 interact.go                                   |  84 ++++++++++
 interact_test.go                              | 153 ++++++++++++++++++
 main.go                                       |   1 +
 sections.go                                   |   2 +-
 ui.go                                         |  25 ++-
 8 files changed, 297 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 72308fb..144d0b6 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ Boards are per-directory. `sidecar init` refuses a board that is a symlink — t
 
 - Renders Markdown with [glamour] and re-renders the moment the file changes. Sidecar watches the parent directory with fsnotify and a 100-millisecond debounce, so it handles atomic rename-swaps, deletes, and recreates — and waits quietly when the file doesn’t exist yet.
 - Scrolls with `j` and `k`, the arrow keys, `PgUp` and `PgDn`, and `g` and `G` for top and bottom. Sidecar keeps your scroll position across reloads. It doesn’t capture the mouse by default, so your terminal’s text selection and clickable links keep working.
-- Acts on items from the keyboard. `]` and `[` select an item; `x` ticks a `- [ ]` item, `1`–`9` (or `y`, `n`, `d`) answer an item's `Ask: yes | no` line, and `d` sends any other item to Done. Each action writes one line change to the board, and the agent's next-turn hook reports it — `edited 🧠: "Ship it" — ticked`, or `— answered "no"`. `M` turns on mouse mode for clicks; press it again to get native text selection back.
+- Acts on items from the keyboard. `]` and `[` select an item; `x` ticks a `- [ ]` item, `1`–`9` (or `y`, `n`, `d`) answer an item's `Ask: yes | no` line, `a` types a free-text answer in the status bar (enter sends, esc cancels), `}` and `{` jump between open questions, and `d` sends any other item to Done. The status bar counts the questions still waiting on you. Each action writes one line change to the board, and the agent's next-turn hook reports it — `edited 🧠: "Ship it" — ticked`, or `— answered "no"`. `M` turns on mouse mode for clicks; press it again to get native text selection back.
 - `Tab` and `Shift+Tab` move a cursor between sections; `Enter` or `Space` collapses or expands the section under it. `✅ Done` and `📦 Shipped` start collapsed — every heading shows its item count, e.g. `✅ Done (12)`.
 - Reloads on demand with `r`, and quits with `q`.
 - Re-renders when you resize the terminal, at the pane width minus 2. It never renders wider than the pane.
diff --git a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
index f14838d..c216a07 100644
--- a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
+++ b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
@@ -13,11 +13,12 @@ Plain markdown, nothing new to parse beyond two line prefixes.
 
 - `- [ ]` / `- [x]` — a checklist item. `x` toggles it.
 - `  Ask: yes | no | done` — an indented line under an item; options are separated by `|` and can be any words (`and`, `or`, …).
+- An `Ask:` line with no options is an open question; the human answers it with `a`. Free text is collapsed to one line, so an answer never hard-wraps the board.
 - `  Answer: no` — written directly under the `Ask:` line. A new answer replaces the old one, so an item carries at most one.
 
 ## Keys
 
-`]` / `[` select the next or previous item. With one selected: `x` ticks; `1`–`9` answer by position; `y` / `n` / `d` answer `yes` / `no` / `done` when offered; `d` otherwise moves the item to ✅ Done; `esc` deselects. `M` toggles mouse mode: a click selects an item, a click on its box ticks it.
+`]` / `[` select the next or previous item. With one selected: `x` ticks; `1`–`9` answer by position; `y` / `n` / `d` answer `yes` / `no` / `done` when offered; `a` opens a free-text answer in the status bar (enter writes it, esc abandons it; every key is text while typing); `}` / `{` select the next or previous unanswered question; `d` otherwise moves the item to ✅ Done; `esc` deselects. `M` toggles mouse mode: a click selects an item, a click on its box ticks it.
 
 ## Writes
 
@@ -31,6 +32,10 @@ Plain markdown, nothing new to parse beyond two line prefixes.
 - `sidecar diff` appends `— ticked`, `— unticked`, or `— answered "x"` to the edited line.
 - The CLAUDE.md note teaches the `Ask:` / `Answer:` convention through `entryStyleRules`.
 
+## Async questions
+
+The board is the channel: the agent asks by writing an `Ask:` line and moves on; the human answers whenever they look at the viewer. The status bar counts open questions (`N awaiting you`), and the hook reports each answer on the agent's next turn. An unanswered question stays in 🧠 Needs you.
+
 ## Known limits
 
 - The item cursor maps items to rendered lines by their column-0 marker (`•`, `□`, `✓`). A section whose rendered count differs from the parsed count, such as a collapsed section, is skipped rather than mis-selected.
diff --git a/edit.go b/edit.go
index c73b520..afcfd3b 100644
--- a/edit.go
+++ b/edit.go
@@ -64,6 +64,33 @@ func askOptions(it BoardItem) []string {
 	return nil
 }
 
+// hasAsk reports whether the item carries an "Ask:" line at all — options or
+// not. An Ask: with no options is an open question, answered in free text.
+func hasAsk(it BoardItem) bool {
+	_, rest, _ := strings.Cut(it.Raw, "\n")
+	for _, ln := range strings.Split(rest, "\n") {
+		if strings.HasPrefix(strings.TrimSpace(ln), "Ask:") {
+			return true
+		}
+	}
+	return false
+}
+
+// isUnanswered reports a question still waiting on the human.
+func isUnanswered(it BoardItem) bool { return hasAsk(it) && answerOf(it) == "" }
+
+// cleanAnswer reduces typed text to one plain line: control characters and
+// newlines become spaces, runs of space collapse, and the ends are trimmed.
+func cleanAnswer(s string) string {
+	s = strings.Map(func(r rune) rune {
+		if r < 0x20 || r == 0x7f {
+			return ' '
+		}
+		return r
+	}, s)
+	return strings.Join(strings.Fields(s), " ")
+}
+
 // answerOf returns the item's current "Answer:" value, "" when unanswered.
 func answerOf(it BoardItem) string {
 	_, rest, _ := strings.Cut(it.Raw, "\n")
diff --git a/interact.go b/interact.go
index 58743b9..18a2dd5 100644
--- a/interact.go
+++ b/interact.go
@@ -139,6 +139,9 @@ func (m *model) itemKey(key string) bool {
 	case key == "x" && isCheckbox(it):
 		m.apply(label, it, replaceLines(toggleCheckbox), "")
 		return true
+	case key == "a" && hasAsk(it):
+		m.typing, m.input = true, ""
+		return true
 	case len(opts) > 0 && optionForKey(key, opts) != "":
 		choice := optionForKey(key, opts)
 		m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, choice) }), "answered "+choice)
@@ -201,6 +204,9 @@ func (m model) hint() string {
 		return ""
 	}
 	parts := []string{"[ prev · ] next"}
+	if hasAsk(it) {
+		parts = append(parts, "a type answer")
+	}
 	if isCheckbox(it) {
 		parts = append(parts, "x tick")
 	}
@@ -254,3 +260,81 @@ func (m *model) toggleMouse() tea.Cmd {
 	m.notice = "mouse off — native selection restored"
 	return tea.DisableMouse
 }
+
+// typeKey handles a keypress while an answer is being typed in the status
+// bar: text appends, backspace deletes, enter writes the answer, esc (or
+// ctrl+c) abandons it. Every key is consumed, so typing "q" or "d" into an
+// answer never quits or moves anything.
+func (m *model) typeKey(msg tea.KeyMsg) {
+	switch msg.Type {
+	case tea.KeyEsc, tea.KeyCtrlC:
+		m.typing, m.input = false, ""
+	case tea.KeyEnter:
+		text := cleanAnswer(m.input)
+		m.typing, m.input = false, ""
+		if it, label, ok := m.selected(); ok && text != "" {
+			m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, text) }), "answered")
+		}
+	case tea.KeyBackspace:
+		if r := []rune(m.input); len(r) > 0 {
+			m.input = string(r[:len(r)-1])
+		}
+	case tea.KeySpace:
+		m.input += " "
+	case tea.KeyRunes:
+		m.input += string(msg.Runes)
+	}
+}
+
+// pendingQuestions counts unanswered Ask: items outside the finished
+// sections — what is waiting on the human.
+func (m model) pendingQuestions() int {
+	n := 0
+	for _, s := range m.board.Sections {
+		if strings.HasSuffix(s.Label, "Done") || strings.HasSuffix(s.Label, "Shipped") {
+			continue
+		}
+		for _, it := range s.Items {
+			if isUnanswered(it) {
+				n++
+			}
+		}
+	}
+	return n
+}
+
+// moveQuestionCursor selects the next (+1) or previous (-1) unanswered
+// question that is visible, wrapping, and says so when none is waiting.
+func (m *model) moveQuestionCursor(delta int) {
+	type pos struct{ s, i int }
+	var all []pos
+	cur := -1
+	for si, starts := range m.itemStarts {
+		for ii := range starts {
+			if si == m.itemSec && ii == m.itemIdx {
+				cur = len(all)
+			}
+			all = append(all, pos{si, ii})
+		}
+	}
+	n := len(all)
+	for step := 1; step <= n; step++ {
+		var idx int
+		switch {
+		case cur >= 0:
+			idx = ((cur+delta*step)%n + n) % n
+		case delta > 0:
+			idx = step - 1
+		default:
+			idx = n - step
+		}
+		p := all[idx]
+		if isUnanswered(m.board.Sections[p.s].Items[p.i]) {
+			m.itemSec, m.itemIdx, m.cursor = p.s, p.i, p.s
+			m.recompose()
+			m.scrollTo(m.itemStarts[p.s][p.i])
+			return
+		}
+	}
+	m.notice = "no questions waiting"
+}
diff --git a/interact_test.go b/interact_test.go
index cef4f17..165b460 100644
--- a/interact_test.go
+++ b/interact_test.go
@@ -150,3 +150,156 @@ func TestMouseClickOnStatusBarRowIgnored(t *testing.T) {
 		t.Fatal("status bar click acted on an item")
 	}
 }
+
+const questionBoard = `# Board
+
+## 🧠 Needs you
+
+- Which name?
+  Ask:
+  Next: answer
+- Merge now?
+  Ask: yes | no
+  Next: answer
+- Old question
+  Ask: yes | no
+  Answer: yes
+
+## ✅ Done
+
+- shipped
+  Ask: yes | no
+`
+
+func questionModel(t *testing.T) (model, string) {
+	t.Helper()
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, questionBoard)
+	return testModel(t, p), p
+}
+
+func typeText(t *testing.T, m model, s string) model {
+	t.Helper()
+	next, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(s)})
+	return next.(model)
+}
+
+func special(t *testing.T, m model, k tea.KeyType) model {
+	t.Helper()
+	next, _ := m.Update(tea.KeyMsg{Type: k})
+	return next.(model)
+}
+
+func TestFreeTextAnswer(t *testing.T) {
+	m, p := questionModel(t)
+	m = press(t, m, "]", "a")
+	if !m.typing {
+		t.Fatal("a on an Ask: item should open the answer line")
+	}
+	// q, d, and ] are text while typing — they must not quit, move, or select.
+	m = typeText(t, m, "qd] nap")
+	m = special(t, m, tea.KeySpace)
+	m = typeText(t, m, "time")
+	m = special(t, m, tea.KeyBackspace)
+	m = special(t, m, tea.KeyEnter)
+	got := readFile(t, p)
+	if !strings.Contains(got, "  Ask:\n  Answer: qd] nap tim\n  Next: answer") {
+		t.Fatalf("answer not written under the Ask: line:\n%s", got)
+	}
+	if m.typing || m.input != "" {
+		t.Fatal("typing state should clear after enter")
+	}
+}
+
+func TestFreeTextEscAbandons(t *testing.T) {
+	m, p := questionModel(t)
+	m = press(t, m, "]", "a")
+	m = typeText(t, m, "nope")
+	m = special(t, m, tea.KeyEsc)
+	if m.typing || strings.Contains(readFile(t, p), "Answer: nope") {
+		t.Fatal("esc must abandon the answer")
+	}
+}
+
+func TestFreeTextEmptyWritesNothing(t *testing.T) {
+	m, p := questionModel(t)
+	m = press(t, m, "]", "a")
+	m = typeText(t, m, "  ")
+	special(t, m, tea.KeyEnter)
+	if readFile(t, p) != questionBoard {
+		t.Fatal("blank answer must not write")
+	}
+}
+
+func TestFreeTextOnQuestionWithOptions(t *testing.T) {
+	m, p := questionModel(t)
+	m = press(t, m, "]", "]", "a")
+	m = typeText(t, m, "yes, after lunch")
+	special(t, m, tea.KeyEnter)
+	if !strings.Contains(readFile(t, p), "  Answer: yes, after lunch\n") {
+		t.Fatalf("custom answer on an optioned question:\n%s", readFile(t, p))
+	}
+}
+
+func TestAKeyIgnoredWithoutAsk(t *testing.T) {
+	m, _ := interactModel(t)
+	m = press(t, m, "]", "a")
+	if m.typing {
+		t.Fatal("a must only open on an item that asks")
+	}
+}
+
+func TestCleanAnswerIsOneLine(t *testing.T) {
+	if got := cleanAnswer(" a\nb\t\x1b[31mc  d "); got != "a b [31mc d" {
+		t.Fatalf("%q", got)
+	}
+}
+
+func TestPendingQuestionsCountsOpenOnesOutsideDone(t *testing.T) {
+	m, _ := questionModel(t)
+	if got := m.pendingQuestions(); got != 2 {
+		t.Fatalf("pending = %d, want 2 (answered and Done ones excluded)", got)
+	}
+	if bar := stripANSI(m.statusBar()); !strings.Contains(bar, "2 awaiting you") {
+		t.Fatalf("status bar %q", bar)
+	}
+}
+
+func TestQuestionNavigationSkipsAnsweredAndWraps(t *testing.T) {
+	m, _ := questionModel(t)
+	m = press(t, m, "}")
+	if it, _, _ := m.selected(); it.Key != "Which name?" {
+		t.Fatalf("first: %q", it.Key)
+	}
+	m = press(t, m, "}")
+	if it, _, _ := m.selected(); it.Key != "Merge now?" {
+		t.Fatalf("second: %q", it.Key)
+	}
+	m = press(t, m, "}")
+	if it, _, _ := m.selected(); it.Key != "Which name?" {
+		t.Fatalf("wrap: %q", it.Key)
+	}
+	m = press(t, m, "{")
+	if it, _, _ := m.selected(); it.Key != "Merge now?" {
+		t.Fatalf("back: %q", it.Key)
+	}
+}
+
+func TestQuestionNavigationFromAnsweredItemSteps(t *testing.T) {
+	m, _ := questionModel(t)
+	m = press(t, m, "]", "]", "]") // the answered item
+	m = press(t, m, "}")
+	if it, _, _ := m.selected(); it.Key != "Which name?" {
+		t.Fatalf("next from answered wraps to first question, got %q", it.Key)
+	}
+}
+
+func TestQuestionNavigationNoneWaiting(t *testing.T) {
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, "## 🧠 Needs you\n\n- just a note\n")
+	m := testModel(t, p)
+	m = press(t, m, "}")
+	if !strings.Contains(m.notice, "no questions") {
+		t.Fatalf("notice %q", m.notice)
+	}
+}
diff --git a/main.go b/main.go
index 300cbfa..dae42ac 100644
--- a/main.go
+++ b/main.go
@@ -37,6 +37,7 @@ keys:  j/k, arrows, PgUp/PgDn                scroll
        ] / [                                select next / previous item
          x  tick a - [ ] item               1-9  answer an "Ask:" option
          y / n / d  answer yes / no / done  d    otherwise move item to Done
+         a  type a free-text answer         } / {  next / previous open question
          esc  deselect
        M                                    mouse mode: click an item, click its box
        r                                    force reload
diff --git a/sections.go b/sections.go
index 0c0a844..1192a1f 100644
--- a/sections.go
+++ b/sections.go
@@ -160,7 +160,7 @@ func entryStyleRules(sections []Section, bullet string) string {
 		}
 		b.WriteString(" until it needs a decision, and then the `Next:` line asks for that decision.\n")
 	}
-	b.WriteString("\nAn entry asks a quick question with an indented `Ask: yes | no` line — options separated by `|`, any words. The human answers in the viewer, and an `Answer:` line appears under it; read it on your next turn, act on it, then move the item out of its section or drop the `Ask:` and `Answer:` pair so it stops asking. A `- [ ]` checklist item works the same way — the human ticks it, and it reads `- [x]`.\n")
+	b.WriteString("\nAn entry asks a quick question with an indented `Ask: yes | no` line — options separated by `|`, any words — or no options, for an open question the human answers in their own words. The human answers in the viewer, and an `Answer:` line appears under it; read it on your next turn, act on it, then move the item out of its section or drop the `Ask:` and `Answer:` pair so it stops asking. A `- [ ]` checklist item works the same way — the human ticks it, and it reads `- [x]`.\n")
 	return b.String()
 }
 
diff --git a/ui.go b/ui.go
index 7b502c7..ba1d7f6 100644
--- a/ui.go
+++ b/ui.go
@@ -90,6 +90,8 @@ type model struct {
 	itemStarts       [][]int
 	notice           string
 	mouse            bool
+	typing           bool   // an answer is being typed in the status bar
+	input            string // the answer typed so far
 }
 
 func newModel(path string, noFlash bool) model {
@@ -113,6 +115,10 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 
 	case tea.KeyMsg:
+		if m.typing {
+			m.typeKey(msg)
+			return m, nil
+		}
 		m.notice = ""
 		if m.itemKey(msg.String()) {
 			return m, nil
@@ -126,6 +132,12 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		case "[":
 			m.moveItemCursor(-1)
 			return m, nil
+		case "}":
+			m.moveQuestionCursor(1)
+			return m, nil
+		case "{":
+			m.moveQuestionCursor(-1)
+			return m, nil
 		case "M":
 			return m, m.toggleMouse()
 		case "esc":
@@ -510,14 +522,25 @@ func (m model) statusBar() string {
 	}
 
 	left := " 🚗 " + name + " "
+	pct := fmt.Sprintf(" %3.0f%% ", m.vp.ScrollPercent()*100)
 	info := "· " + updated
+	if q := m.pendingQuestions(); q > 0 && !m.fileMissing && m.loadErr == nil {
+		info += fmt.Sprintf(" · %d awaiting you", q)
+	}
 	switch h := m.hint(); {
+	case m.typing:
+		const lead = "· answer: "
+		room := max(0, m.width-visibleWidth(left)-visibleWidth(pct)-visibleWidth(lead)-1)
+		shown := m.input
+		for visibleWidth(shown) > room && shown != "" {
+			shown = string([]rune(shown)[1:]) // keep the end, where the cursor is
+		}
+		info = lead + shown + "▌"
 	case m.notice != "":
 		info = "· " + m.notice
 	case h != "":
 		info = "· " + h
 	}
-	pct := fmt.Sprintf(" %3.0f%% ", m.vp.ScrollPercent()*100)
 
 	pad := m.width - visibleWidth(left) - visibleWidth(info) - visibleWidth(pct)
 	if pad < 0 {

From 58ae1a8b05589a27662ebe7268115de08564d796 Mon Sep 17 00:00:00 2001
From: Than Tibbetts <than@broomfitters.com>
Date: Tue, 29 Sep 2026 14:46:59 -0400
Subject: [PATCH 04/11] Draw Ask: options as clickable buttons
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The board keeps the plain "Ask: ✅ Done | ❌ No" line; the viewer renders each
option as a shaded button, plus a [ ✎ ] button for a free-text answer, and
ticks the recorded answer. In mouse mode a click on a button answers. Letter
keys match an option by its letters, so an emoji option like ✅ Done still
answers to d.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 README.md                                     |   2 +-
 buttons.go                                    |  95 ++++++++++++++
 buttons_test.go                               | 124 ++++++++++++++++++
 ...6-09-29-interactive-line-updates-design.md |   4 +
 interact.go                                   |  13 +-
 main.go                                       |   2 +-
 sections.go                                   |   2 +-
 ui.go                                         |   6 +-
 8 files changed, 240 insertions(+), 8 deletions(-)
 create mode 100644 buttons.go
 create mode 100644 buttons_test.go

diff --git a/README.md b/README.md
index 144d0b6..4e0a2c2 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ Boards are per-directory. `sidecar init` refuses a board that is a symlink — t
 
 - Renders Markdown with [glamour] and re-renders the moment the file changes. Sidecar watches the parent directory with fsnotify and a 100-millisecond debounce, so it handles atomic rename-swaps, deletes, and recreates — and waits quietly when the file doesn’t exist yet.
 - Scrolls with `j` and `k`, the arrow keys, `PgUp` and `PgDn`, and `g` and `G` for top and bottom. Sidecar keeps your scroll position across reloads. It doesn’t capture the mouse by default, so your terminal’s text selection and clickable links keep working.
-- Acts on items from the keyboard. `]` and `[` select an item; `x` ticks a `- [ ]` item, `1`–`9` (or `y`, `n`, `d`) answer an item's `Ask: yes | no` line, `a` types a free-text answer in the status bar (enter sends, esc cancels), `}` and `{` jump between open questions, and `d` sends any other item to Done. The status bar counts the questions still waiting on you. Each action writes one line change to the board, and the agent's next-turn hook reports it — `edited 🧠: "Ship it" — ticked`, or `— answered "no"`. `M` turns on mouse mode for clicks; press it again to get native text selection back.
+- Acts on items from the keyboard. `]` and `[` select an item; `x` ticks a `- [ ]` item, `1`–`9` (or `y`, `n`, `d`) answer an item's `Ask: yes | no` line — the viewer draws each option as a button, `[ ✅ Done ]  [ ❌ No ]  [ ✎ ]`, and mouse mode makes them clickable — `a` types a free-text answer in the status bar (enter sends, esc cancels), `}` and `{` jump between open questions, and `d` sends any other item to Done. The status bar counts the questions still waiting on you. Each action writes one line change to the board, and the agent's next-turn hook reports it — `edited 🧠: "Ship it" — ticked`, or `— answered "no"`. `M` turns on mouse mode for clicks; press it again to get native text selection back.
 - `Tab` and `Shift+Tab` move a cursor between sections; `Enter` or `Space` collapses or expands the section under it. `✅ Done` and `📦 Shipped` start collapsed — every heading shows its item count, e.g. `✅ Done (12)`.
 - Reloads on demand with `r`, and quits with `q`.
 - Re-renders when you resize the terminal, at the pane width minus 2. It never renders wider than the pane.
diff --git a/buttons.go b/buttons.go
new file mode 100644
index 0000000..496fd86
--- /dev/null
+++ b/buttons.go
@@ -0,0 +1,95 @@
+// buttons.go — draw an item's Ask: line as buttons. The board file keeps
+// the plain "Ask: yes | no" line; the viewer swaps it, at display time, for
+// shaded chips — [ yes ]  [ no ]  [ ✎ ] — with the chosen answer ticked.
+// In mouse mode a click on a chip answers.
+package main
+
+import (
+	"strings"
+	"unicode"
+)
+
+// freeChip is the button that opens the free-text answer line.
+const freeChip = "[ ✎ ]"
+
+// chipText is one option as drawn: "[ ✅ Done ]", or "[ ✓ ✅ Done ]" once
+// it is the recorded answer.
+func chipText(opt string, chosen bool) string {
+	opt = strings.ReplaceAll(opt, "`", "")
+	if chosen {
+		return "[ ✓ " + opt + " ]"
+	}
+	return "[ " + opt + " ]"
+}
+
+// chips returns an item's buttons in order, with the free-text button last.
+func chips(it BoardItem) []string {
+	ans := answerOf(it)
+	var out []string
+	for _, o := range askOptions(it) {
+		out = append(out, chipText(o, ans != "" && strings.EqualFold(ans, o)))
+	}
+	return append(out, freeChip)
+}
+
+// buttonize rewrites every Ask: line as its buttons, one code span each.
+// The line count never changes, so board line indices stay valid for
+// applyCollapse.
+func buttonize(raw string, board Board) string {
+	lines := strings.Split(raw, "\n")
+	for _, s := range board.Sections {
+		for _, it := range s.Items {
+			if !hasAsk(it) {
+				continue
+			}
+			for i := it.StartLine + 1; i <= it.EndLine && i < len(lines); i++ {
+				trimmed := strings.TrimSpace(lines[i])
+				if !strings.HasPrefix(trimmed, "Ask:") {
+					continue
+				}
+				indent := lines[i][:len(lines[i])-len(strings.TrimLeft(lines[i], " \t"))]
+				var spans []string
+				for _, c := range chips(it) {
+					spans = append(spans, "`"+c+"`")
+				}
+				lines[i] = indent + strings.Join(spans, " ")
+				break
+			}
+		}
+	}
+	return strings.Join(lines, "\n")
+}
+
+// normalizeOption reduces an option to its letters and digits, lowercase,
+// so "✅ Done" answers to d and "👍 Yes" to y.
+func normalizeOption(o string) string {
+	return strings.Map(func(r rune) rune {
+		if unicode.IsLetter(r) || unicode.IsDigit(r) {
+			return unicode.ToLower(r)
+		}
+		return -1
+	}, o)
+}
+
+// chipAt finds which of the item's buttons covers display column x on a
+// rendered line: option is the answer to write, free is the ✎ button. ok is
+// false when x is not on a button.
+func chipAt(it BoardItem, renderedLine string, x int) (option string, free, ok bool) {
+	text := stripANSI(renderedLine)
+	opts := askOptions(it)
+	for i, c := range chips(it) {
+		idx := strings.Index(text, c)
+		if idx < 0 {
+			continue
+		}
+		col := visibleWidth(text[:idx])
+		if x < col || x >= col+visibleWidth(c) {
+			continue
+		}
+		if i < len(opts) {
+			return opts[i], false, true
+		}
+		return "", true, true
+	}
+	return "", false, false
+}
diff --git a/buttons_test.go b/buttons_test.go
new file mode 100644
index 0000000..667d8f7
--- /dev/null
+++ b/buttons_test.go
@@ -0,0 +1,124 @@
+package main
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+const buttonBoard = `# Board
+
+## 🧠 Needs you
+
+- Merge now?
+  Ask: ✅ Done | ❌ No
+  Next: answer
+
+## ✅ Done
+
+- old
+`
+
+func buttonModel(t *testing.T) (model, string) {
+	t.Helper()
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, buttonBoard)
+	return testModel(t, p), p
+}
+
+func TestButtonizeKeepsLineCountAndDrawsChips(t *testing.T) {
+	b, _ := parseBoard(buttonBoard)
+	got := buttonize(buttonBoard, b)
+	if strings.Count(got, "\n") != strings.Count(buttonBoard, "\n") {
+		t.Fatal("buttonize changed the line count")
+	}
+	if !strings.Contains(got, "  `[ ✅ Done ]` `[ ❌ No ]` `[ ✎ ]`\n") {
+		t.Fatalf("chips missing:\n%s", got)
+	}
+}
+
+func TestButtonizeTicksTheChosenAnswer(t *testing.T) {
+	raw := strings.Replace(buttonBoard, "  Next: answer", "  Answer: ❌ No\n  Next: answer", 1)
+	b, _ := parseBoard(raw)
+	if got := buttonize(raw, b); !strings.Contains(got, "`[ ✓ ❌ No ]`") || strings.Contains(got, "`[ ❌ No ]`") {
+		t.Fatalf("chosen chip not ticked:\n%s", got)
+	}
+}
+
+func TestOpenQuestionGetsOnlyTheWriteButton(t *testing.T) {
+	raw := "## 🧠 Needs you\n\n- Name?\n  Ask:\n"
+	b, _ := parseBoard(raw)
+	if got := buttonize(raw, b); !strings.Contains(got, "  `[ ✎ ]`") {
+		t.Fatalf("got %q", got)
+	}
+}
+
+func TestButtonsRenderInThePane(t *testing.T) {
+	m, _ := buttonModel(t)
+	view := stripANSI(m.vp.View())
+	if !strings.Contains(view, "[ ✅ Done ]") || !strings.Contains(view, "[ ❌ No ]") || strings.Contains(view, "Ask:") {
+		t.Fatalf("pane:\n%s", view)
+	}
+}
+
+func TestEmojiOptionsAnswerToLetterKeys(t *testing.T) {
+	m, p := buttonModel(t)
+	m = press(t, m, "]", "n")
+	if got := readFile(t, p); !strings.Contains(got, "Answer: ❌ No") {
+		t.Fatalf("n should pick ❌ No:\n%s", got)
+	}
+	press(t, m, "d")
+	if got := readFile(t, p); !strings.Contains(got, "Answer: ✅ Done") || strings.Count(got, "Answer:") != 1 {
+		t.Fatalf("d should pick ✅ Done:\n%s", got)
+	}
+}
+
+func clickAt(t *testing.T, m model, text string, x int) model {
+	t.Helper()
+	for i, ln := range m.renderedLines {
+		if idx := strings.Index(stripANSI(ln), text); idx >= 0 {
+			msg := tea.MouseMsg{X: visibleWidth(stripANSI(ln)[:idx]) + x, Y: i - m.vp.YOffset, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft}
+			next, _ := m.Update(msg)
+			return next.(model)
+		}
+	}
+	t.Fatalf("no rendered line contains %q", text)
+	return m
+}
+
+func TestClickingAButtonAnswers(t *testing.T) {
+	m, p := buttonModel(t)
+	m = press(t, m, "M")
+	clickAt(t, m, "[ ❌ No ]", 2)
+	if got := readFile(t, p); !strings.Contains(got, "  Answer: ❌ No\n") {
+		t.Fatalf("click did not answer:\n%s", got)
+	}
+}
+
+func TestClickingTheWriteButtonOpensTyping(t *testing.T) {
+	m, _ := buttonModel(t)
+	m = press(t, m, "M")
+	m = clickAt(t, m, freeChip, 1)
+	if !m.typing {
+		t.Fatal("✎ button should open the answer line")
+	}
+}
+
+func TestClickBetweenButtonsOnlySelects(t *testing.T) {
+	m, p := buttonModel(t)
+	m = press(t, m, "M")
+	m = clickAt(t, m, "Next: answer", 0)
+	if m.itemSec < 0 || readFile(t, p) != buttonBoard {
+		t.Fatal("a click off the buttons should select, not write")
+	}
+}
+
+func TestClickIgnoredWithoutMouseMode(t *testing.T) {
+	m, p := buttonModel(t)
+	clickAt(t, m, "[ ❌ No ]", 2)
+	if readFile(t, p) != buttonBoard {
+		t.Fatal("buttons must not respond while mouse mode is off")
+	}
+}
diff --git a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
index c216a07..8bb6a1b 100644
--- a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
+++ b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
@@ -16,6 +16,10 @@ Plain markdown, nothing new to parse beyond two line prefixes.
 - An `Ask:` line with no options is an open question; the human answers it with `a`. Free text is collapsed to one line, so an answer never hard-wraps the board.
 - `  Answer: no` — written directly under the `Ask:` line. A new answer replaces the old one, so an item carries at most one.
 
+## Buttons
+
+The file keeps the plain `Ask: ✅ Done | ❌ No` line. At display time the viewer swaps it for one shaded button per option plus a `[ ✎ ]` button that opens the free-text answer — `[ ✅ Done ]  [ ❌ No ]  [ ✎ ]` — and ticks the recorded answer (`[ ✓ ❌ No ]`). In mouse mode a click on a button answers; the keys work without it. Options may carry emoji; `y` / `n` / `d` match by the option's letters (`✅ Done` answers to `d`).
+
 ## Keys
 
 `]` / `[` select the next or previous item. With one selected: `x` ticks; `1`–`9` answer by position; `y` / `n` / `d` answer `yes` / `no` / `done` when offered; `a` opens a free-text answer in the status bar (enter writes it, esc abandons it; every key is text while typing); `}` / `{` select the next or previous unanswered question; `d` otherwise moves the item to ✅ Done; `esc` deselects. `M` toggles mouse mode: a click selects an item, a click on its box ticks it.
diff --git a/interact.go b/interact.go
index 18a2dd5..ea8f491 100644
--- a/interact.go
+++ b/interact.go
@@ -167,7 +167,7 @@ func optionForKey(key string, opts []string) string {
 	}
 	want := map[string]string{"y": "yes", "n": "no", "d": "done"}[key]
 	for _, o := range opts {
-		if want != "" && strings.EqualFold(o, want) {
+		if want != "" && normalizeOption(o) == want {
 			return o
 		}
 	}
@@ -218,6 +218,9 @@ func (m model) hint() string {
 		parts = append(parts, strings.Join(o, "  "))
 	}
 	parts = append(parts, "d done", "esc")
+	if hasAsk(it) && !m.mouse {
+		parts = append(parts, "M click buttons")
+	}
 	return strings.Join(parts, " · ")
 }
 
@@ -243,7 +246,13 @@ func (m *model) mouseClick(x, y int) {
 			}
 			m.itemSec, m.itemIdx, m.cursor = si, ii, si
 			m.recompose()
-			if it, label, _ := m.selected(); x <= 1 && line == start && isCheckbox(it) {
+			it, label, _ := m.selected()
+			switch opt, free, hit := chipAt(it, m.renderedLines[line], x); {
+			case hit && free:
+				m.typing, m.input = true, ""
+			case hit:
+				m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, opt) }), "answered "+opt)
+			case x <= 1 && line == start && isCheckbox(it):
 				m.apply(label, it, replaceLines(toggleCheckbox), "")
 			}
 			return
diff --git a/main.go b/main.go
index dae42ac..a7152d6 100644
--- a/main.go
+++ b/main.go
@@ -39,7 +39,7 @@ keys:  j/k, arrows, PgUp/PgDn                scroll
          y / n / d  answer yes / no / done  d    otherwise move item to Done
          a  type a free-text answer         } / {  next / previous open question
          esc  deselect
-       M                                    mouse mode: click an item, click its box
+       M                                    mouse mode: click an item, its box, or an [ answer ] button
        r                                    force reload
        q                                    quit
 
diff --git a/sections.go b/sections.go
index 1192a1f..6bb8628 100644
--- a/sections.go
+++ b/sections.go
@@ -160,7 +160,7 @@ func entryStyleRules(sections []Section, bullet string) string {
 		}
 		b.WriteString(" until it needs a decision, and then the `Next:` line asks for that decision.\n")
 	}
-	b.WriteString("\nAn entry asks a quick question with an indented `Ask: yes | no` line — options separated by `|`, any words — or no options, for an open question the human answers in their own words. The human answers in the viewer, and an `Answer:` line appears under it; read it on your next turn, act on it, then move the item out of its section or drop the `Ask:` and `Answer:` pair so it stops asking. A `- [ ]` checklist item works the same way — the human ticks it, and it reads `- [x]`.\n")
+	b.WriteString("\nAn entry asks a quick question with an indented `Ask: yes | no` line — options separated by `|`, any words, emoji welcome (`Ask: ✅ Done | ❌ No`); the viewer draws each option as a button — or no options, for an open question the human answers in their own words. The human answers in the viewer, and an `Answer:` line appears under it; read it on your next turn, act on it, then move the item out of its section or drop the `Ask:` and `Answer:` pair so it stops asking. A `- [ ]` checklist item works the same way — the human ticks it, and it reads `- [x]`.\n")
 	return b.String()
 }
 
diff --git a/ui.go b/ui.go
index ba1d7f6..012d42f 100644
--- a/ui.go
+++ b/ui.go
@@ -320,7 +320,7 @@ func (m *model) reload(force bool) (changed bool) {
 	}
 	displayRaw := raw
 	if boardOK {
-		displayRaw = applyCollapse(raw, board, m.collapsed)
+		displayRaw = applyCollapse(buttonize(raw, board), board, m.collapsed)
 	}
 
 	rendered, err := renderMarkdown(displayRaw, m.renderWidth(), true)
@@ -347,7 +347,7 @@ func (m *model) reload(force bool) (changed bool) {
 		// a live viewer setting, not a property of any one file revision.
 		baseDisplay := m.prevBaseline
 		if baseBoard, ok := parseBoard(m.prevBaseline); ok {
-			baseDisplay = applyCollapse(m.prevBaseline, baseBoard, m.collapsed)
+			baseDisplay = applyCollapse(buttonize(m.prevBaseline, baseBoard), baseBoard, m.collapsed)
 		}
 		if base, berr := renderMarkdown(baseDisplay, m.renderWidth(), true); berr == nil {
 			changedMap = changedLines(strings.Split(base, "\n"), lines)
@@ -393,7 +393,7 @@ func (m *model) rerenderCollapse() {
 	if !m.ready || m.fileMissing || m.loadErr != nil || len(m.board.Sections) == 0 {
 		return
 	}
-	displayRaw := applyCollapse(m.raw, m.board, m.collapsed)
+	displayRaw := applyCollapse(buttonize(m.raw, m.board), m.board, m.collapsed)
 	rendered, err := renderMarkdown(displayRaw, m.renderWidth(), true)
 	if err != nil {
 		return // m.raw already rendered fine on the last successful reload

From 24e9f55ea8dc4145d34bcc564087825d9bfe30da Mon Sep 17 00:00:00 2001
From: Than Tibbetts <than@broomfitters.com>
Date: Tue, 29 Sep 2026 15:00:10 -0400
Subject: [PATCH 05/11] Put Done and Reply buttons under every open item,
 always clickable
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Every item outside Done and Shipped gets [ ✅ Done ] and [ 💬 Reply ] below it.
Reply takes free text, pre-filled with the current reply, and lands as an
Answer: line; an agent's narrative Ask: line shows as the question. Mouse
capture is on by default (--no-mouse and M release it). A new PostToolUse hook,
sidecar diff --mid-turn, hands a reply to the agent after its next tool call.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 README.md                                     |   5 +-
 buttons.go                                    | 181 +++++++++++++---
 buttons_test.go                               | 204 ++++++++++++++----
 diffcmd.go                                    |  67 +++++-
 diffcmd_test.go                               |  30 +++
 ...6-09-29-interactive-line-updates-design.md |  53 ++---
 edit.go                                       |  31 ++-
 edit_test.go                                  |   2 +-
 init.go                                       |  31 +++
 init_test.go                                  |  10 +-
 interact.go                                   |  63 ++++--
 interact_test.go                              |   8 -
 main.go                                       |  43 ++--
 sections.go                                   |   2 +-
 semdiff.go                                    |  11 +-
 ui.go                                         |  12 +-
 16 files changed, 580 insertions(+), 173 deletions(-)

diff --git a/README.md b/README.md
index 4e0a2c2..e6ec952 100644
--- a/README.md
+++ b/README.md
@@ -36,8 +36,9 @@ Boards are per-directory. `sidecar init` refuses a board that is a symlink — t
 ## What it does
 
 - Renders Markdown with [glamour] and re-renders the moment the file changes. Sidecar watches the parent directory with fsnotify and a 100-millisecond debounce, so it handles atomic rename-swaps, deletes, and recreates — and waits quietly when the file doesn’t exist yet.
-- Scrolls with `j` and `k`, the arrow keys, `PgUp` and `PgDn`, and `g` and `G` for top and bottom. Sidecar keeps your scroll position across reloads. It doesn’t capture the mouse by default, so your terminal’s text selection and clickable links keep working.
-- Acts on items from the keyboard. `]` and `[` select an item; `x` ticks a `- [ ]` item, `1`–`9` (or `y`, `n`, `d`) answer an item's `Ask: yes | no` line — the viewer draws each option as a button, `[ ✅ Done ]  [ ❌ No ]  [ ✎ ]`, and mouse mode makes them clickable — `a` types a free-text answer in the status bar (enter sends, esc cancels), `}` and `{` jump between open questions, and `d` sends any other item to Done. The status bar counts the questions still waiting on you. Each action writes one line change to the board, and the agent's next-turn hook reports it — `edited 🧠: "Ship it" — ticked`, or `— answered "no"`. `M` turns on mouse mode for clicks; press it again to get native text selection back.
+- Scrolls with `j` and `k`, the arrow keys, `PgUp` and `PgDn`, and `g` and `G` for top and bottom, or with the mouse wheel. Sidecar keeps your scroll position across reloads.
+- Talks back to the agent. Under every open item the viewer draws two buttons, `[ ✅ Done ]` and `[ 💬 Reply ]`. Click Reply, type in your own words, and press Enter: your reply lands under the item as an `Answer:` line, and `sidecar`'s hook hands it to the agent after its next tool call — no chat message needed. Done moves the item to ✅ Done. An agent that wants something from you writes an indented `Ask:` line with a narrative question, which shows as `💬 …` above the buttons; `Ask: ✅ Go | ❌ Hold` draws a button per choice instead.
+- Clicks work by default — buttons, checkboxes, items, and section headers. Mouse capture costs the terminal's plain drag-to-select: hold Shift (Option in iTerm2) to select anyway, press `M` to switch capture off and on, or start with `--no-mouse`. Everything also has a key: `]` and `[` select an item, `a` replies, `x` ticks a `- [ ]` item, `d` sends an item to Done, `1`–`9` pick a choice, `}` and `{` jump between open questions, and `esc` deselects.
 - `Tab` and `Shift+Tab` move a cursor between sections; `Enter` or `Space` collapses or expands the section under it. `✅ Done` and `📦 Shipped` start collapsed — every heading shows its item count, e.g. `✅ Done (12)`.
 - Reloads on demand with `r`, and quits with `q`.
 - Re-renders when you resize the terminal, at the pane width minus 2. It never renders wider than the pane.
diff --git a/buttons.go b/buttons.go
index 496fd86..cdcb61d 100644
--- a/buttons.go
+++ b/buttons.go
@@ -1,19 +1,51 @@
-// buttons.go — draw an item's Ask: line as buttons. The board file keeps
-// the plain "Ask: yes | no" line; the viewer swaps it, at display time, for
-// shaded chips — [ yes ]  [ no ]  [ ✎ ] — with the chosen answer ticked.
-// In mouse mode a click on a chip answers.
+// buttons.go — the action row under every open item. The board file stays
+// plain text; at display time the viewer draws, beneath each item outside
+// ✅ Done and 📦 Shipped, shaded buttons:
+//
+//	[ ✅ Done ]  [ 💬 Reply ]
+//
+// Reply opens a free-text line (pre-filled with the current reply), Done
+// moves the item to ✅ Done. An "Ask: a | b" line draws its choices as
+// buttons of their own; a narrative "Ask: what did you change?" line shows as
+// the question the reply answers. Clicking any button needs no item selected.
 package main
 
 import (
+	"regexp"
 	"strings"
 	"unicode"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+const (
+	doneChip      = "[ ✅ Done ]"
+	replyChip     = "[ 💬 Reply ]"
+	editReplyChip = "[ 💬 Edit reply ]"
+)
+
+var (
+	buttonStyle = lipgloss.NewStyle().Bold(true).
+			Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#7AA2F7"))
+	buttonGoStyle = lipgloss.NewStyle().Bold(true).
+			Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#9ECE6A"))
+	chipRun = regexp.MustCompile(`\[ [^\]]+ \]`)
+	countIn = regexp.MustCompile(` \(\d+\)$`)
 )
 
-// freeChip is the button that opens the free-text answer line.
-const freeChip = "[ ✎ ]"
+// finishedLabel reports a ✅ Done or 📦 Shipped heading, with or without the
+// " (N)" item count the display rewrite appends.
+func finishedLabel(label string) bool {
+	label = countIn.ReplaceAllString(label, "")
+	return strings.HasSuffix(label, "Done") || strings.HasSuffix(label, "Shipped")
+}
+
+// actionable is an item that gets an action row: real, and not finished.
+func actionable(label string, it BoardItem) bool {
+	return !finishedLabel(label) && it.Key != emptySectionPlaceholder
+}
 
-// chipText is one option as drawn: "[ ✅ Done ]", or "[ ✓ ✅ Done ]" once
-// it is the recorded answer.
+// chipText is one choice as drawn: "[ yes ]", or "[ ✓ yes ]" once recorded.
 func chipText(opt string, chosen bool) string {
 	opt = strings.ReplaceAll(opt, "`", "")
 	if chosen {
@@ -22,42 +54,109 @@ func chipText(opt string, chosen bool) string {
 	return "[ " + opt + " ]"
 }
 
-// chips returns an item's buttons in order, with the free-text button last.
-func chips(it BoardItem) []string {
+// optionChips are the buttons of an "Ask: a | b" line, the recorded one ticked.
+func optionChips(it BoardItem) []string {
 	ans := answerOf(it)
 	var out []string
 	for _, o := range askOptions(it) {
 		out = append(out, chipText(o, ans != "" && strings.EqualFold(ans, o)))
 	}
-	return append(out, freeChip)
+	return out
 }
 
-// buttonize rewrites every Ask: line as its buttons, one code span each.
-// The line count never changes, so board line indices stay valid for
-// applyCollapse.
+func replyChipFor(it BoardItem) string {
+	if answerOf(it) != "" {
+		return editReplyChip
+	}
+	return replyChip
+}
+
+// rowChips are the buttons under an item, in order.
+func rowChips(it BoardItem) []string { return []string{doneChip, replyChipFor(it)} }
+
+func codeSpans(chips []string) string {
+	spans := make([]string, len(chips))
+	for i, c := range chips {
+		spans[i] = "`" + c + "`"
+	}
+	return strings.Join(spans, " ")
+}
+
+// buttonize adds each open item's action row and redraws its Ask: line. It
+// may add lines, so run it on the text that will actually be rendered, after
+// applyCollapse; board must be parseBoard of that same text.
 func buttonize(raw string, board Board) string {
 	lines := strings.Split(raw, "\n")
+	replace := map[int]string{}
+	after := map[int]string{}
 	for _, s := range board.Sections {
 		for _, it := range s.Items {
-			if !hasAsk(it) {
+			if !actionable(s.Label, it) {
 				continue
 			}
 			for i := it.StartLine + 1; i <= it.EndLine && i < len(lines); i++ {
-				trimmed := strings.TrimSpace(lines[i])
-				if !strings.HasPrefix(trimmed, "Ask:") {
+				if !strings.HasPrefix(strings.TrimSpace(lines[i]), "Ask:") {
 					continue
 				}
 				indent := lines[i][:len(lines[i])-len(strings.TrimLeft(lines[i], " \t"))]
-				var spans []string
-				for _, c := range chips(it) {
-					spans = append(spans, "`"+c+"`")
+				if opts := optionChips(it); len(opts) > 0 {
+					replace[i] = indent + codeSpans(opts)
+				} else if q := askText(it); q != "" {
+					replace[i] = indent + "💬 " + q
 				}
-				lines[i] = indent + strings.Join(spans, " ")
 				break
 			}
+			after[it.EndLine] = "  " + codeSpans(rowChips(it))
+		}
+	}
+	var out []string
+	for i, ln := range lines {
+		if r, ok := replace[i]; ok {
+			ln = r
+		}
+		out = append(out, ln)
+		if row, ok := after[i]; ok {
+			out = append(out, row)
 		}
 	}
-	return strings.Join(lines, "\n")
+	return strings.Join(out, "\n")
+}
+
+// displayText is the board as rendered: collapsed sections dropped and counts
+// added, then every open item's buttons.
+func displayText(raw string, board Board, collapsed map[string]bool) string {
+	collapsedRaw := applyCollapse(raw, board, collapsed)
+	if b, ok := parseBoard(collapsedRaw); ok {
+		return buttonize(collapsedRaw, b)
+	}
+	return collapsedRaw
+}
+
+// styleButtons repaints every line made only of buttons with solid colors —
+// blue, and green for Done and a recorded choice — so they read as controls
+// rather than inline code. Visible text is unchanged, so chipAt still finds
+// each button's columns.
+func styleButtons(lines []string) []string {
+	out := make([]string, len(lines))
+	for i, ln := range lines {
+		out[i] = ln
+		t := stripANSI(ln)
+		body := strings.TrimSpace(t)
+		if !strings.HasPrefix(body, "[ ") || strings.TrimSpace(chipRun.ReplaceAllString(body, "")) != "" {
+			continue
+		}
+		indent := t[:len(t)-len(strings.TrimLeft(t, " "))]
+		var parts []string
+		for _, c := range chipRun.FindAllString(body, -1) {
+			if c == doneChip || strings.HasPrefix(c, "[ ✓ ") {
+				parts = append(parts, buttonGoStyle.Render(c))
+			} else {
+				parts = append(parts, buttonStyle.Render(c))
+			}
+		}
+		out[i] = indent + strings.Join(parts, "  ")
+	}
+	return out
 }
 
 // normalizeOption reduces an option to its letters and digits, lowercase,
@@ -71,25 +170,37 @@ func normalizeOption(o string) string {
 	}, o)
 }
 
+type chipKind int
+
+const (
+	chipOption chipKind = iota
+	chipDone
+	chipReply
+)
+
 // chipAt finds which of the item's buttons covers display column x on a
-// rendered line: option is the answer to write, free is the ✎ button. ok is
-// false when x is not on a button.
-func chipAt(it BoardItem, renderedLine string, x int) (option string, free, ok bool) {
+// rendered line; ok is false when x is not on a button. For chipOption,
+// option is the choice to record.
+func chipAt(it BoardItem, renderedLine string, x int) (kind chipKind, option string, ok bool) {
 	text := stripANSI(renderedLine)
-	opts := askOptions(it)
-	for i, c := range chips(it) {
+	hit := func(c string) bool {
 		idx := strings.Index(text, c)
 		if idx < 0 {
-			continue
+			return false
 		}
 		col := visibleWidth(text[:idx])
-		if x < col || x >= col+visibleWidth(c) {
-			continue
-		}
-		if i < len(opts) {
-			return opts[i], false, true
+		return x >= col && x < col+visibleWidth(c)
+	}
+	for i, c := range optionChips(it) {
+		if hit(c) {
+			return chipOption, askOptions(it)[i], true
 		}
-		return "", true, true
 	}
-	return "", false, false
+	switch {
+	case hit(doneChip):
+		return chipDone, "", true
+	case hit(replyChipFor(it)):
+		return chipReply, "", true
+	}
+	return 0, "", false
 }
diff --git a/buttons_test.go b/buttons_test.go
index 667d8f7..1643e85 100644
--- a/buttons_test.go
+++ b/buttons_test.go
@@ -12,9 +12,9 @@ const buttonBoard = `# Board
 
 ## 🧠 Needs you
 
-- Merge now?
-  Ask: ✅ Done | ❌ No
-  Next: answer
+- Config rewritten — the deploy script now reads the new keys.
+  Ask: What did you change on your side in the meantime?
+  Next: reply
 
 ## ✅ Done
 
@@ -28,50 +28,78 @@ func buttonModel(t *testing.T) (model, string) {
 	return testModel(t, p), p
 }
 
-func TestButtonizeKeepsLineCountAndDrawsChips(t *testing.T) {
+func TestEveryOpenItemGetsAnActionRowBelowIt(t *testing.T) {
+	raw := "## 🧠 Needs you\n\n- plain\n- has detail\n  more\n\n## ✅ Done\n\n- finished\n"
+	b, _ := parseBoard(raw)
+	got := buttonize(raw, b)
+	row := "  `[ ✅ Done ]` `[ 💬 Reply ]`"
+	if strings.Count(got, row) != 2 {
+		t.Fatalf("want a row under each of the 2 open items, none under Done:\n%s", got)
+	}
+	if !strings.Contains(got, "- plain\n"+row+"\n- has detail\n  more\n"+row+"\n") {
+		t.Fatalf("rows must sit directly below their item:\n%s", got)
+	}
+}
+
+func TestNoRowUnderDoneOrShippedOrPlaceholder(t *testing.T) {
+	raw := "## ✅ Done (1)\n\n- a\n\n## 📦 Shipped\n\n- b\n\n## 🚧 In progress\n\n- " + emptySectionPlaceholder + "\n"
+	b, _ := parseBoard(raw)
+	if got := buttonize(raw, b); strings.Contains(got, "Reply") {
+		t.Fatalf("finished and placeholder items get no buttons:\n%s", got)
+	}
+}
+
+func TestNarrativeAskShowsAsTheQuestion(t *testing.T) {
 	b, _ := parseBoard(buttonBoard)
 	got := buttonize(buttonBoard, b)
-	if strings.Count(got, "\n") != strings.Count(buttonBoard, "\n") {
-		t.Fatal("buttonize changed the line count")
+	if !strings.Contains(got, "  💬 What did you change on your side in the meantime?\n") || strings.Contains(got, "Ask:") {
+		t.Fatalf("question not shown:\n%s", got)
 	}
-	if !strings.Contains(got, "  `[ ✅ Done ]` `[ ❌ No ]` `[ ✎ ]`\n") {
-		t.Fatalf("chips missing:\n%s", got)
+	if askOptions(b.Sections[0].Items[0]) != nil {
+		t.Fatal("a question without | has no choices")
 	}
 }
 
-func TestButtonizeTicksTheChosenAnswer(t *testing.T) {
-	raw := strings.Replace(buttonBoard, "  Next: answer", "  Answer: ❌ No\n  Next: answer", 1)
+func TestChoiceAskStillDrawsChoiceButtons(t *testing.T) {
+	raw := "## 🧠 Needs you\n\n- Merge?\n  Ask: ✅ Go | ❌ Hold\n"
 	b, _ := parseBoard(raw)
-	if got := buttonize(raw, b); !strings.Contains(got, "`[ ✓ ❌ No ]`") || strings.Contains(got, "`[ ❌ No ]`") {
-		t.Fatalf("chosen chip not ticked:\n%s", got)
+	got := buttonize(raw, b)
+	if !strings.Contains(got, "  `[ ✅ Go ]` `[ ❌ Hold ]`\n") {
+		t.Fatalf("choices missing:\n%s", got)
+	}
+	raw2 := strings.Replace(raw, "Ask:", "Answer: ❌ Hold\n  Ask:", 1)
+	b2, _ := parseBoard(raw2)
+	if got := buttonize(raw2, b2); !strings.Contains(got, "`[ ✓ ❌ Hold ]`") {
+		t.Fatalf("recorded choice not ticked:\n%s", got)
 	}
 }
 
-func TestOpenQuestionGetsOnlyTheWriteButton(t *testing.T) {
-	raw := "## 🧠 Needs you\n\n- Name?\n  Ask:\n"
+func TestReplyButtonReadsEditOnceReplied(t *testing.T) {
+	raw := "## 🧠 Needs you\n\n- x\n  Answer: did it\n"
 	b, _ := parseBoard(raw)
-	if got := buttonize(raw, b); !strings.Contains(got, "  `[ ✎ ]`") {
-		t.Fatalf("got %q", got)
+	if got := buttonize(raw, b); !strings.Contains(got, "`[ 💬 Edit reply ]`") {
+		t.Fatalf("got:\n%s", got)
 	}
 }
 
-func TestButtonsRenderInThePane(t *testing.T) {
+func TestDisplayTextSurvivesCollapseCounts(t *testing.T) {
 	m, _ := buttonModel(t)
-	view := stripANSI(m.vp.View())
-	if !strings.Contains(view, "[ ✅ Done ]") || !strings.Contains(view, "[ ❌ No ]") || strings.Contains(view, "Ask:") {
-		t.Fatalf("pane:\n%s", view)
+	got := displayText(m.raw, m.board, map[string]bool{"✅ Done": true})
+	if !strings.Contains(got, "## ✅ Done (1)") || strings.Count(got, "[ ✅ Done ]") != 1 {
+		t.Fatalf("got:\n%s", got)
 	}
 }
 
-func TestEmojiOptionsAnswerToLetterKeys(t *testing.T) {
-	m, p := buttonModel(t)
-	m = press(t, m, "]", "n")
-	if got := readFile(t, p); !strings.Contains(got, "Answer: ❌ No") {
-		t.Fatalf("n should pick ❌ No:\n%s", got)
+func TestButtonsRenderInThePane(t *testing.T) {
+	m, _ := buttonModel(t)
+	view := stripANSI(m.vp.View())
+	for _, want := range []string{"[ ✅ Done ]", "[ 💬 Reply ]", "What did you change"} {
+		if !strings.Contains(view, want) {
+			t.Fatalf("pane missing %q:\n%s", want, view)
+		}
 	}
-	press(t, m, "d")
-	if got := readFile(t, p); !strings.Contains(got, "Answer: ✅ Done") || strings.Count(got, "Answer:") != 1 {
-		t.Fatalf("d should pick ✅ Done:\n%s", got)
+	if strings.Contains(view, "Ask:") {
+		t.Fatalf("raw Ask: line leaked:\n%s", view)
 	}
 }
 
@@ -88,37 +116,125 @@ func clickAt(t *testing.T, m model, text string, x int) model {
 	return m
 }
 
-func TestClickingAButtonAnswers(t *testing.T) {
+func TestClickReplyOpensPrefilledLineWithoutSelectingFirst(t *testing.T) {
 	m, p := buttonModel(t)
-	m = press(t, m, "M")
-	clickAt(t, m, "[ ❌ No ]", 2)
-	if got := readFile(t, p); !strings.Contains(got, "  Answer: ❌ No\n") {
-		t.Fatalf("click did not answer:\n%s", got)
+	m.mouse = true
+	m = clickAt(t, m, replyChip, 3)
+	if !m.typing || m.input != "" {
+		t.Fatalf("reply button should open an empty answer line, typing=%v input=%q", m.typing, m.input)
+	}
+	m = typeText(t, m, "Restarted the worker by hand")
+	special(t, m, tea.KeyEnter)
+	if got := readFile(t, p); !strings.Contains(got, "  Ask: What did you change on your side in the meantime?\n  Answer: Restarted the worker by hand\n") {
+		t.Fatalf("reply not written under the question:\n%s", got)
 	}
 }
 
-func TestClickingTheWriteButtonOpensTyping(t *testing.T) {
-	m, _ := buttonModel(t)
-	m = press(t, m, "M")
-	m = clickAt(t, m, freeChip, 1)
-	if !m.typing {
-		t.Fatal("✎ button should open the answer line")
+func TestEditReplyPrefillsTheExistingText(t *testing.T) {
+	m, p := buttonModel(t)
+	m.mouse = true
+	m = clickAt(t, m, replyChip, 3)
+	m = typeText(t, m, "first")
+	m = special(t, m, tea.KeyEnter)
+	if !strings.Contains(readFile(t, p), "Answer: first") {
+		t.Fatal("setup: reply not written")
+	}
+	m = clickAt(t, m, editReplyChip, 3)
+	if m.input != "first" {
+		t.Fatalf("edit should prefill, got %q", m.input)
+	}
+	m = typeText(t, m, " and second")
+	special(t, m, tea.KeyEnter)
+	if got := readFile(t, p); strings.Count(got, "Answer:") != 1 || !strings.Contains(got, "Answer: first and second") {
+		t.Fatalf("reply not replaced:\n%s", got)
+	}
+}
+
+func TestUnpromptedReplyLandsLastOnAnItemThatAskedNothing(t *testing.T) {
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, "## 🧠 Needs you\n\n- Create the API key\n  Next: create it\n")
+	m := testModel(t, p)
+	m.mouse = true
+	m = clickAt(t, m, replyChip, 3)
+	m = typeText(t, m, "made it, pasted in .env")
+	special(t, m, tea.KeyEnter)
+	if got := readFile(t, p); !strings.HasSuffix(got, "  Next: create it\n  Answer: made it, pasted in .env\n") {
+		t.Fatalf("got:\n%s", got)
+	}
+}
+
+func TestClickDoneMovesItAndRecordsWhoDidIt(t *testing.T) {
+	m, p := buttonModel(t)
+	m.mouse = true
+	clickAt(t, m, doneChip, 3)
+	b, _ := parseBoard(readFile(t, p))
+	if len(b.Sections[0].Items) != 0 || len(b.Sections[1].Items) != 2 {
+		t.Fatalf("not moved:\n%s", readFile(t, p))
+	}
+	if answerOf(b.Sections[1].Items[1]) != "✅ Done" {
+		t.Fatalf("Done should leave a reply the hook can read:\n%s", readFile(t, p))
+	}
+}
+
+func TestDoneKeepsAnExistingReply(t *testing.T) {
+	m, p := buttonModel(t)
+	m.mouse = true
+	m = clickAt(t, m, replyChip, 3)
+	m = typeText(t, m, "did it differently")
+	m = special(t, m, tea.KeyEnter)
+	clickAt(t, m, doneChip, 3)
+	if got := readFile(t, p); !strings.Contains(got, "Answer: did it differently") || strings.Contains(got, "Answer: ✅ Done") {
+		t.Fatalf("Done must not overwrite a narrative reply:\n%s", got)
+	}
+}
+
+func TestOptionButtonClickRecordsTheChoice(t *testing.T) {
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, "## 🧠 Needs you\n\n- Merge?\n  Ask: Go | Hold\n")
+	m := testModel(t, p)
+	m.mouse = true
+	clickAt(t, m, "[ Hold ]", 2)
+	if got := readFile(t, p); !strings.Contains(got, "  Answer: Hold\n") {
+		t.Fatalf("got:\n%s", got)
 	}
 }
 
 func TestClickBetweenButtonsOnlySelects(t *testing.T) {
 	m, p := buttonModel(t)
-	m = press(t, m, "M")
-	m = clickAt(t, m, "Next: answer", 0)
+	m.mouse = true
+	m = clickAt(t, m, "Next: reply", 0)
 	if m.itemSec < 0 || readFile(t, p) != buttonBoard {
 		t.Fatal("a click off the buttons should select, not write")
 	}
 }
 
-func TestClickIgnoredWithoutMouseMode(t *testing.T) {
+func TestClickIgnoredWhenMouseIsOff(t *testing.T) {
 	m, p := buttonModel(t)
-	clickAt(t, m, "[ ❌ No ]", 2)
+	clickAt(t, m, doneChip, 3)
 	if readFile(t, p) != buttonBoard {
-		t.Fatal("buttons must not respond while mouse mode is off")
+		t.Fatal("buttons must not respond while mouse is off")
+	}
+}
+
+func TestEmojiChoiceAnswersToLetterKeys(t *testing.T) {
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, "## 🧠 Needs you\n\n- Merge?\n  Ask: ✅ Done | ❌ No\n")
+	m := testModel(t, p)
+	m = press(t, m, "]", "n")
+	if !strings.Contains(readFile(t, p), "Answer: ❌ No") {
+		t.Fatalf("n should pick ❌ No:\n%s", readFile(t, p))
+	}
+}
+
+func TestAKeyRepliesOnAnyItem(t *testing.T) {
+	m, p := buttonModel(t)
+	m = press(t, m, "]", "a")
+	if !m.typing {
+		t.Fatal("a should open the reply line on any item")
+	}
+	m = typeText(t, m, "ok")
+	special(t, m, tea.KeyEnter)
+	if !strings.Contains(readFile(t, p), "Answer: ok") {
+		t.Fatalf("got:\n%s", readFile(t, p))
 	}
 }
diff --git a/diffcmd.go b/diffcmd.go
index eec0462..e7458d9 100644
--- a/diffcmd.go
+++ b/diffcmd.go
@@ -5,6 +5,7 @@ package main
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
 	"hash/fnv"
 	"os"
@@ -13,23 +14,35 @@ import (
 )
 
 func runDiff(args []string) int {
-	if len(args) > 1 {
+	operands := 0
+	for _, a := range args {
+		if a != "--mid-turn" {
+			operands++
+		}
+	}
+	if operands > 1 {
 		fmt.Fprintln(os.Stderr, "sidecar diff: too many arguments")
 		return 2
 	}
 	path := defaultBoardPath()
-	if len(args) > 0 {
-		switch args[0] {
-		case "-h", "--help":
-			fmt.Println("usage: sidecar diff [file.md]")
+	midTurn, havePath := false, false
+	for _, a := range args {
+		switch {
+		case a == "-h" || a == "--help":
+			fmt.Println("usage: sidecar diff [--mid-turn] [file.md]")
 			fmt.Println("Prints board changes since the last run.")
+			fmt.Println("--mid-turn prints only the human's replies and ticks, as PostToolUse hook JSON, and stays silent otherwise.")
 			return 0
+		case a == "--mid-turn":
+			midTurn = true
+		case strings.HasPrefix(a, "-"):
+			fmt.Fprintf(os.Stderr, "sidecar diff: unknown flag %q\n", a)
+			return 2
+		case havePath:
+			fmt.Fprintln(os.Stderr, "sidecar diff: too many arguments")
+			return 2
 		default:
-			if strings.HasPrefix(args[0], "-") {
-				fmt.Fprintf(os.Stderr, "sidecar diff: unknown flag %q\n", args[0])
-				return 2
-			}
-			path = args[0]
+			path, havePath = a, true
 		}
 	}
 	abs, err := filepath.Abs(expandTilde(path))
@@ -62,6 +75,9 @@ func runDiff(args []string) int {
 	if bytes.Equal(prev, raw) {
 		return 0
 	}
+	if midTurn {
+		return midTurnReport(path, snap, string(prev), string(raw))
+	}
 
 	for _, line := range cappedDiffLines(diffLines(string(prev), string(raw))) {
 		fmt.Println(line)
@@ -193,3 +209,34 @@ func closingReminder(rel, raw string) string {
 	}
 	return reconcileMessageLabels(rel, labels)
 }
+
+// midTurnReport is the PostToolUse half of the hook cycle: it surfaces only
+// what the human did in the viewer — a reply, a tick — as hook JSON that adds
+// context to the running turn. Anything else stays silent and leaves the
+// snapshot alone, so the per-prompt diff still reports it. The snapshot moves
+// only when something was reported, so the same reply is never delivered twice.
+func midTurnReport(path, snap, prev, raw string) int {
+	ob, ok1 := parseBoard(prev)
+	nb, ok2 := parseBoard(raw)
+	if !ok1 || !ok2 {
+		return 0
+	}
+	var lines []string
+	for _, l := range semanticDiff(ob, nb) {
+		if strings.Contains(l, " — replied ") || strings.Contains(l, " — ticked") || strings.Contains(l, " — unticked") {
+			lines = append(lines, l)
+		}
+	}
+	if len(lines) == 0 {
+		return 0
+	}
+	msg := "The human answered on the sidecar board while you worked:\n" + strings.Join(cappedDiffLines(lines), "\n") +
+		"\nRead " + path + ", act on the reply, then clear the item's Ask: and Answer: lines or move it."
+	out, _ := json.Marshal(map[string]any{"hookSpecificOutput": map[string]any{
+		"hookEventName":     "PostToolUse",
+		"additionalContext": msg,
+	}})
+	fmt.Println(string(out))
+	writeSnapshot(snap, []byte(raw))
+	return 0
+}
diff --git a/diffcmd_test.go b/diffcmd_test.go
index 57e9b89..4e274ad 100644
--- a/diffcmd_test.go
+++ b/diffcmd_test.go
@@ -434,3 +434,33 @@ func TestDefaultBoardPathFreshDefault(t *testing.T) {
 		}
 	})
 }
+
+func TestMidTurnReportsRepliesAndStaysSilentOtherwise(t *testing.T) {
+	dir := t.TempDir()
+	withWorkDir(t, dir, func() {
+		board := filepath.Join(dir, ".sidecar", "sidecar.md")
+		os.MkdirAll(filepath.Dir(board), 0o755)
+		base := "## 🧠 Needs you\n\n- Ship\n  Ask: What changed?\n"
+		os.WriteFile(board, []byte(base), 0o644)
+		run := func() string {
+			var out string
+			out = captureStdout(t, func() { runDiff([]string{"--mid-turn"}) })
+			return out
+		}
+		if run() != "" {
+			t.Fatal("first run seeds silently")
+		}
+		os.WriteFile(board, []byte(base+"  Next: x\n"), 0o644)
+		if got := run(); got != "" {
+			t.Fatalf("an agent-side edit must stay silent mid-turn, got %q", got)
+		}
+		os.WriteFile(board, []byte(base+"  Answer: I fixed the key\n  Next: x\n"), 0o644)
+		got := run()
+		if !strings.Contains(got, `"hookEventName":"PostToolUse"`) || !strings.Contains(got, "replied") || !strings.Contains(got, "I fixed the key") {
+			t.Fatalf("reply not reported as hook JSON: %q", got)
+		}
+		if again := run(); again != "" {
+			t.Fatalf("a reply must be delivered once, got %q", again)
+		}
+	})
+}
diff --git a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
index 8bb6a1b..93f06fe 100644
--- a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
+++ b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
@@ -1,46 +1,49 @@
 # Interactive line updates
 
-The viewer gains one write path: the human acts on a board item and sidecar writes that one line change back. The per-turn hook already diffs the board, so the agent reads the decision on its next turn.
+The viewer gains one write path so the human can answer the agent from the board, and the hook cycle hands the answer to the agent mid-turn.
 
 ## Intent
 
-- The human ticks a checklist item, answers a yes/no/and/or/done prompt, or sends an item to ✅ Done without typing in chat.
-- Keyboard first. Native text selection and clickable links stay the default; mouse clicks work only while mouse mode (`M`) is on.
+- An agent leaves the result of a turn as an entry. The human, who may be in another tab, says what they did in between, in their own words.
+- The agent asks a narrative question, not a yes/no.
+- Always clickable: mouse capture is on by default (`--no-mouse` and `M` release it). Shift-drag (Option in iTerm2) still selects text.
 
-## Board syntax
+## What the human sees
 
-Plain markdown, nothing new to parse beyond two line prefixes.
+Under every open item — everything outside ✅ Done and 📦 Shipped — two buttons:
 
-- `- [ ]` / `- [x]` — a checklist item. `x` toggles it.
-- `  Ask: yes | no | done` — an indented line under an item; options are separated by `|` and can be any words (`and`, `or`, …).
-- An `Ask:` line with no options is an open question; the human answers it with `a`. Free text is collapsed to one line, so an answer never hard-wraps the board.
-- `  Answer: no` — written directly under the `Ask:` line. A new answer replaces the old one, so an item carries at most one.
+    [ ✅ Done ]  [ 💬 Reply ]
 
-## Buttons
+- **Reply** opens a free-text line in the status bar, pre-filled with the current reply. Enter writes `Answer: <text>` under the item, replacing an earlier one; esc abandons it. While typing, every key is text.
+- **Done** moves the item to ✅ Done. When the human has said nothing else it also writes `Answer: ✅ Done`, so the hook can tell a human finished it.
+- An `Ask:` line with no `|` is the question. It shows as `💬 <question>` above the buttons. An `Ask: a | b` line is a choice and draws one button per option; the recorded choice is ticked.
 
-The file keeps the plain `Ask: ✅ Done | ❌ No` line. At display time the viewer swaps it for one shaded button per option plus a `[ ✎ ]` button that opens the free-text answer — `[ ✅ Done ]  [ ❌ No ]  [ ✎ ]` — and ticks the recorded answer (`[ ✓ ❌ No ]`). In mouse mode a click on a button answers; the keys work without it. Options may carry emoji; `y` / `n` / `d` match by the option's letters (`✅ Done` answers to `d`).
+## Board syntax
 
-## Keys
+Plain markdown; the file never contains a button.
 
-`]` / `[` select the next or previous item. With one selected: `x` ticks; `1`–`9` answer by position; `y` / `n` / `d` answer `yes` / `no` / `done` when offered; `a` opens a free-text answer in the status bar (enter writes it, esc abandons it; every key is text while typing); `}` / `{` select the next or previous unanswered question; `d` otherwise moves the item to ✅ Done; `esc` deselects. `M` toggles mouse mode: a click selects an item, a click on its box ticks it.
+- `  Ask: what did you change?` — the agent's question.
+- `  Ask: ✅ Go | ❌ Hold` — optional choices.
+- `  Answer: …` — the human's reply. It is written under `Ask:` when there is one and last otherwise, so a reply works on an item that asked nothing.
+- `- [ ]` / `- [x]` — a checklist item; the box ticks on a click in the first two columns or `x`.
 
-## Writes
+## Delivery
 
-- `editItem` re-reads the file, locates the item by section label and exact item text, applies a pure text transform, and swaps the file in by rename, keeping its mode.
-- An edit by the agent elsewhere in the file survives. If the item itself changed since the viewer rendered it, nothing is written and the status bar says so.
-- Only three mutations exist: toggle a checkbox, set an answer, move an item to Done. Free-form editing is out of scope.
+- `sidecar diff` (UserPromptSubmit) is unchanged and reports everything since the last prompt.
+- `sidecar diff --mid-turn` (PostToolUse) prints hook JSON only when the human replied or ticked, and stays silent for anything else, including the agent's own edits. It advances the snapshot only when it reported, so a reply arrives once.
+- `sidecar init` installs both hooks; the mid-turn one carries the same sentinel, so a re-run replaces it.
+- The diff line reads `edited 🧠: "Title" — replied "…"`; a tick reads `— ticked`.
 
-## Agent side
+## Writes
 
-- A task-list marker is state, not identity, so `normalizeItem` strips it: ticking reads as `edited`, not remove-plus-add.
-- `sidecar diff` appends `— ticked`, `— unticked`, or `— answered "x"` to the edited line.
-- The CLAUDE.md note teaches the `Ask:` / `Answer:` convention through `entryStyleRules`.
+`editItem` re-reads the file, finds the item by section label and exact text, applies a pure text transform, and swaps the file in by rename, keeping its mode. An agent edit elsewhere survives; if the item itself changed since it was rendered, nothing is written and the status bar says so.
 
-## Async questions
+## Keyboard
 
-The board is the channel: the agent asks by writing an `Ask:` line and moves on; the human answers whenever they look at the viewer. The status bar counts open questions (`N awaiting you`), and the hook reports each answer on the agent's next turn. An unanswered question stays in 🧠 Needs you.
+`]` / `[` select an item, `a` replies, `d` sends it to Done, `x` ticks, `1`–`9` and `y` / `n` / `d` pick a choice, `}` / `{` jump between unanswered questions, `esc` deselects. The status bar counts open questions.
 
 ## Known limits
 
-- The item cursor maps items to rendered lines by their column-0 marker (`•`, `□`, `✓`). A section whose rendered count differs from the parsed count, such as a collapsed section, is skipped rather than mis-selected.
-- The rename swap leaves a small window in which a concurrent write by the agent to the same file is lost; the exact-text match narrows it to the same item.
+- Rows are found by their column-0 marker; a section whose rendered count differs from the parsed count (collapsed) is skipped rather than mis-selected.
+- When `--mid-turn` reports, the snapshot advances whole, so an agent edit made in the same window is not repeated in the next prompt's diff.
+- Clicking a link: capture may stop the terminal's own link handling; the viewer does not open links itself yet.
diff --git a/edit.go b/edit.go
index afcfd3b..688d599 100644
--- a/edit.go
+++ b/edit.go
@@ -52,6 +52,9 @@ func askOptions(it BoardItem) []string {
 	_, rest, _ := strings.Cut(it.Raw, "\n")
 	for _, ln := range strings.Split(rest, "\n") {
 		if v, ok := strings.CutPrefix(strings.TrimSpace(ln), "Ask:"); ok {
+			if !strings.Contains(v, "|") {
+				return nil // a narrative question, not a choice
+			}
 			var opts []string
 			for _, o := range strings.Split(v, "|") {
 				if o = strings.TrimSpace(o); o != "" {
@@ -91,6 +94,18 @@ func cleanAnswer(s string) string {
 	return strings.Join(strings.Fields(s), " ")
 }
 
+// askText is the question on an item's "Ask:" line when it is narrative —
+// no "|" choices — and "" otherwise.
+func askText(it BoardItem) string {
+	_, rest, _ := strings.Cut(it.Raw, "\n")
+	for _, ln := range strings.Split(rest, "\n") {
+		if v, ok := strings.CutPrefix(strings.TrimSpace(ln), "Ask:"); ok && !strings.Contains(v, "|") {
+			return strings.TrimSpace(v)
+		}
+	}
+	return ""
+}
+
 // answerOf returns the item's current "Answer:" value, "" when unanswered.
 func answerOf(it BoardItem) string {
 	_, rest, _ := strings.Cut(it.Raw, "\n")
@@ -102,8 +117,9 @@ func answerOf(it BoardItem) string {
 	return ""
 }
 
-// setAnswer writes "Answer: <option>" directly under the Ask: line,
-// replacing an earlier answer so the item never carries two.
+// setAnswer writes "Answer: <option>" directly under the Ask: line — or last,
+// when the item asked nothing — replacing an earlier answer so the item never
+// carries two.
 func setAnswer(lines []string, option string) ([]string, error) {
 	askAt := -1
 	for i, ln := range lines[1:] {
@@ -113,7 +129,16 @@ func setAnswer(lines []string, option string) ([]string, error) {
 		}
 	}
 	if askAt < 0 {
-		return nil, errors.New("no Ask: line on this item")
+		// An unprompted reply: the human volunteers something about an item
+		// the agent never asked about. It goes last, replacing an earlier one.
+		var out []string
+		for i, ln := range lines {
+			if i > 0 && strings.HasPrefix(strings.TrimSpace(ln), "Answer:") {
+				continue
+			}
+			out = append(out, ln)
+		}
+		return append(out, "  Answer: "+option), nil
 	}
 	indent := lines[askAt][:len(lines[askAt])-len(strings.TrimLeft(lines[askAt], " \t"))]
 	var out []string
diff --git a/edit_test.go b/edit_test.go
index f9ea72a..c9ea9ce 100644
--- a/edit_test.go
+++ b/edit_test.go
@@ -157,7 +157,7 @@ func TestDiffNamesTickAndAnswer(t *testing.T) {
 	ob, _ := parseBoard(old)
 	nb, _ := parseBoard(next)
 	got := strings.Join(semanticDiff(ob, nb), "\n")
-	for _, want := range []string{`edited 🧠: "Ship it" — ticked`, `edited 🧠: "Pick" — answered "no"`} {
+	for _, want := range []string{`edited 🧠: "Ship it" — ticked`, `edited 🧠: "Pick" — replied "no"`} {
 		if !strings.Contains(got, want) {
 			t.Fatalf("missing %q in:\n%s", want, got)
 		}
diff --git a/init.go b/init.go
index 479dc32..179a380 100644
--- a/init.go
+++ b/init.go
@@ -521,6 +521,35 @@ func reconcileHookEntry(rel string, sections []Section) map[string]any {
 	}
 }
 
+// midTurnHookEntry is the PostToolUse half of the cycle: after every tool call
+// it asks `sidecar diff --mid-turn` whether the human replied in the viewer,
+// so an answer reaches the agent mid-turn instead of waiting for the next
+// prompt. It stays silent otherwise, fails open on an older binary, and
+// carries the sentinel so a re-run of init replaces it rather than stacking.
+func midTurnHookEntry(rel string) map[string]any {
+	diffCmd := "sidecar diff --mid-turn"
+	if !isDefaultBoardRel(rel) {
+		diffCmd += " " + shSingleQuote(rel)
+	}
+	cmd := "sidecar diff --help </dev/null >/dev/null 2>&1 && " + diffCmd + " 2>/dev/null; true # " + hookSentinel
+	return map[string]any{
+		"hooks": []any{
+			map[string]any{"type": "command", "command": cmd},
+		},
+	}
+}
+
+// addMidTurnHook appends entry under PostToolUse. Call it after
+// mergeReconcileHook, which has already removed any prior sidecar entry.
+func addMidTurnHook(settings, entry map[string]any) {
+	hooks, ok := settings["hooks"].(map[string]any)
+	if !ok {
+		return
+	}
+	ptu, _ := hooks["PostToolUse"].([]any)
+	hooks["PostToolUse"] = append(ptu, entry)
+}
+
 // writeReconcileHook installs a UserPromptSubmit hook — the only hook type
 // that fires every turn, so the queue actually stays current. It merges into
 // an existing .claude/settings.json, replacing any prior sidecar hook
@@ -537,6 +566,7 @@ func writeReconcileHook(root, rel string, sections []Section) (needsAttention bo
 	data, err := os.ReadFile(path)
 	if os.IsNotExist(err) {
 		settings := map[string]any{"hooks": map[string]any{"UserPromptSubmit": []any{entry}}}
+		addMidTurnHook(settings, midTurnHookEntry(rel))
 		if err := writeSettings(path, settings); err != nil {
 			fmt.Fprintln(os.Stderr, "sidecar init:", err)
 			return true
@@ -558,6 +588,7 @@ func writeReconcileHook(root, rel string, sections []Section) (needsAttention bo
 		fmt.Printf(".claude/settings.json has an unexpected shape — add this hook yourself:\n%s\n", snippetJSON(entry))
 		return true
 	}
+	addMidTurnHook(settings, midTurnHookEntry(rel))
 	if err := writeSettings(path, settings); err != nil {
 		fmt.Fprintln(os.Stderr, "sidecar init:", err)
 		return true
diff --git a/init_test.go b/init_test.go
index 3bd1fa4..5c310ba 100644
--- a/init_test.go
+++ b/init_test.go
@@ -159,9 +159,13 @@ func TestReconcileHookMergesAndUpgrades(t *testing.T) {
 	if !ok || len(ups) != 1 {
 		t.Fatalf("want exactly 1 UserPromptSubmit entry, got:\n%s", data)
 	}
-	// The old sidecar SessionStart hook should be gone (only keep-me remains).
-	if n := strings.Count(string(data), hookSentinel); n != 1 {
-		t.Errorf("sentinel appears %d times, want 1 (old hook not replaced):\n%s", n, data)
+	// The old sidecar SessionStart hook should be gone (only keep-me remains);
+	// what's left is the per-prompt hook plus the mid-turn PostToolUse hook.
+	if n := strings.Count(string(data), hookSentinel); n != 2 {
+		t.Errorf("sentinel appears %d times, want 2 (old hook not replaced, or a duplicate):\n%s", n, data)
+	}
+	if ptu, ok := hooks["PostToolUse"].([]any); !ok || len(ptu) != 1 {
+		t.Errorf("want exactly 1 PostToolUse entry after two runs, got:\n%s", data)
 	}
 }
 
diff --git a/interact.go b/interact.go
index ea8f491..fe7dfe3 100644
--- a/interact.go
+++ b/interact.go
@@ -139,17 +139,15 @@ func (m *model) itemKey(key string) bool {
 	case key == "x" && isCheckbox(it):
 		m.apply(label, it, replaceLines(toggleCheckbox), "")
 		return true
-	case key == "a" && hasAsk(it):
-		m.typing, m.input = true, ""
+	case key == "a":
+		m.typing, m.input = true, answerOf(it)
 		return true
 	case len(opts) > 0 && optionForKey(key, opts) != "":
 		choice := optionForKey(key, opts)
-		m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, choice) }), "answered "+choice)
+		m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, choice) }), "replied "+choice)
 		return true
 	case key == "d":
-		m.apply(label, it, func(raw string, b Board, si, ii int) (string, error) {
-			return moveItem(raw, b, si, ii, doneLabel(b))
-		}, "moved to Done")
+		m.apply(label, it, doneAndMove, "moved to Done")
 		m.itemSec, m.itemIdx = -1, -1
 		return true
 	}
@@ -203,10 +201,7 @@ func (m model) hint() string {
 	if !ok {
 		return ""
 	}
-	parts := []string{"[ prev · ] next"}
-	if hasAsk(it) {
-		parts = append(parts, "a type answer")
-	}
+	parts := []string{"[ prev · ] next", "a reply"}
 	if isCheckbox(it) {
 		parts = append(parts, "x tick")
 	}
@@ -218,8 +213,8 @@ func (m model) hint() string {
 		parts = append(parts, strings.Join(o, "  "))
 	}
 	parts = append(parts, "d done", "esc")
-	if hasAsk(it) && !m.mouse {
-		parts = append(parts, "M click buttons")
+	if !m.mouse {
+		parts = append(parts, "M mouse on")
 	}
 	return strings.Join(parts, " · ")
 }
@@ -231,6 +226,13 @@ func (m *model) mouseClick(x, y int) {
 		return // the status bar row is not content
 	}
 	line := y + m.vp.YOffset
+	for si, h := range m.headerLines {
+		if h == line {
+			m.cursor = si
+			m.toggleCursor()
+			return
+		}
+	}
 	for si, starts := range m.itemStarts {
 		for ii, start := range starts {
 			end := start + 1
@@ -247,11 +249,14 @@ func (m *model) mouseClick(x, y int) {
 			m.itemSec, m.itemIdx, m.cursor = si, ii, si
 			m.recompose()
 			it, label, _ := m.selected()
-			switch opt, free, hit := chipAt(it, m.renderedLines[line], x); {
-			case hit && free:
-				m.typing, m.input = true, ""
+			switch kind, opt, hit := chipAt(it, m.renderedLines[line], x); {
+			case hit && kind == chipReply:
+				m.typing, m.input = true, answerOf(it)
+			case hit && kind == chipDone:
+				m.apply(label, it, doneAndMove, "moved to Done")
+				m.itemSec, m.itemIdx = -1, -1
 			case hit:
-				m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, opt) }), "answered "+opt)
+				m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, opt) }), "replied "+opt)
 			case x <= 1 && line == start && isCheckbox(it):
 				m.apply(label, it, replaceLines(toggleCheckbox), "")
 			}
@@ -263,10 +268,10 @@ func (m *model) mouseClick(x, y int) {
 func (m *model) toggleMouse() tea.Cmd {
 	m.mouse = !m.mouse
 	if m.mouse {
-		m.notice = "mouse on — click an item, click its box to tick (M to release)"
+		m.notice = "mouse on — click buttons, boxes, items, headers (M to release)"
 		return tea.EnableMouseCellMotion
 	}
-	m.notice = "mouse off — native selection restored"
+	m.notice = "mouse off — native text selection restored (M to click again)"
 	return tea.DisableMouse
 }
 
@@ -282,7 +287,7 @@ func (m *model) typeKey(msg tea.KeyMsg) {
 		text := cleanAnswer(m.input)
 		m.typing, m.input = false, ""
 		if it, label, ok := m.selected(); ok && text != "" {
-			m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, text) }), "answered")
+			m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, text) }), "reply sent")
 		}
 	case tea.KeyBackspace:
 		if r := []rune(m.input); len(r) > 0 {
@@ -347,3 +352,23 @@ func (m *model) moveQuestionCursor(delta int) {
 	}
 	m.notice = "no questions waiting"
 }
+
+// doneAndMove records "✅ Done" as the reply when the human has said nothing
+// else — so the agent's hook can tell a human finished it — then moves the
+// item to ✅ Done.
+func doneAndMove(raw string, b Board, si, ii int) (string, error) {
+	it := b.Sections[si].Items[ii]
+	if answerOf(it) == "" {
+		var err error
+		raw, err = replaceLines(func(l []string) ([]string, error) { return setAnswer(l, "✅ Done") })(raw, b, si, ii)
+		if err != nil {
+			return "", err
+		}
+		nb, ok := parseBoard(raw)
+		if !ok {
+			return "", errBoardChanged
+		}
+		b = nb
+	}
+	return moveItem(raw, b, si, ii, doneLabel(b))
+}
diff --git a/interact_test.go b/interact_test.go
index 165b460..6cb0007 100644
--- a/interact_test.go
+++ b/interact_test.go
@@ -241,14 +241,6 @@ func TestFreeTextOnQuestionWithOptions(t *testing.T) {
 	}
 }
 
-func TestAKeyIgnoredWithoutAsk(t *testing.T) {
-	m, _ := interactModel(t)
-	m = press(t, m, "]", "a")
-	if m.typing {
-		t.Fatal("a must only open on an item that asks")
-	}
-}
-
 func TestCleanAnswerIsOneLine(t *testing.T) {
 	if got := cleanAnswer(" a\nb\t\x1b[31mc  d "); got != "a b [31mc d" {
 		t.Fatalf("%q", got)
diff --git a/main.go b/main.go
index a7152d6..8782619 100644
--- a/main.go
+++ b/main.go
@@ -29,18 +29,23 @@ usage: sidecar [file.md]         (default: .sidecar/sidecar.md)
        sidecar diff [file.md]    print board changes since the last run
        sidecar --static [file]   render once to stdout and exit (no TUI)
        sidecar --no-flash [file] disable the subtle change-flash (▸ still shows)
+       sidecar --no-mouse [file] start without mouse capture (native text selection)
 
-keys:  j/k, arrows, PgUp/PgDn                scroll
+keys:  j/k, arrows, PgUp/PgDn, wheel        scroll
        g / G                                top / bottom
        tab / shift+tab                      move between sections
        enter / space                        collapse / expand section
        ] / [                                select next / previous item
-         x  tick a - [ ] item               1-9  answer an "Ask:" option
-         y / n / d  answer yes / no / done  d    otherwise move item to Done
-         a  type a free-text answer         } / {  next / previous open question
-         esc  deselect
-       M                                    mouse mode: click an item, its box, or an [ answer ] button
+       a                                    reply to the selected item (enter sends)
+       d                                    send the selected item to Done
+       x                                    tick a "- [ ]" item
+       1-9  or  y / n / d                   pick a choice from an "Ask: a | b" line
+       } / {                                next / previous open question
+       esc                                  deselect
        r                                    force reload
+       M                                    mouse on/off. On by default: click the
+                                              [ Done ] / [ Reply ] buttons, boxes, items,
+                                              and section headers. Shift-drag selects text.
        q                                    quit
 
 The file doesn't have to exist yet — sidecar waits for it and renders the
@@ -67,7 +72,7 @@ func main() {
 			if code != 0 || open == "" {
 				os.Exit(code)
 			}
-			os.Exit(runViewer(open, false))
+			os.Exit(runViewer(open, false, false))
 		case "diff":
 			os.Exit(runDiff(os.Args[2:]))
 		}
@@ -75,11 +80,13 @@ func main() {
 
 	// Viewer mode: an optional file path plus the --no-flash flag, any order.
 	path := defaultBoardPath()
-	noFlash := false
+	noFlash, noMouse := false, false
 	for _, a := range os.Args[1:] {
 		switch {
 		case a == "--no-flash":
 			noFlash = true
+		case a == "--no-mouse":
+			noMouse = true
 		case strings.HasPrefix(a, "-"):
 			fmt.Fprintf(os.Stderr, "sidecar: unknown flag %q\n\n", a)
 			fmt.Print(help)
@@ -97,21 +104,29 @@ func main() {
 
 	offerCreate(abs) // if missing and interactive, offer to scaffold before opening
 
-	os.Exit(runViewer(abs, noFlash))
+	os.Exit(runViewer(abs, noFlash, noMouse))
 }
 
 // runViewer opens the live viewer on abs and blocks until the human quits.
 // Shared by viewer mode and by `sidecar init`, which opens the board it just
 // created rather than printing a command to run.
-func runViewer(abs string, noFlash bool) int {
-	p := tea.NewProgram(newModel(abs, noFlash),
+func runViewer(abs string, noFlash, noMouse bool) int {
+	model := newModel(abs, noFlash)
+	opts := []tea.ProgramOption{
 		tea.WithAltScreen(),
 		// The renderer wakes every frame even when idle; the default 60fps
 		// costs ~0.5% CPU per open board. 10fps keeps scrolling responsive.
 		tea.WithFPS(10),
-		// No mouse capture: keeps the terminal's native text selection and
-		// clickable links working. Scroll with the keyboard (see keys below).
-	)
+	}
+	// Mouse capture is on by default so buttons, checkboxes, and section
+	// headers respond to clicks. It costs the terminal's plain drag-to-select
+	// (hold Shift, or Option in iTerm2, to select anyway); --no-mouse starts
+	// without it and M toggles it while running.
+	if !noMouse {
+		model.mouse = true
+		opts = append(opts, tea.WithMouseCellMotion())
+	}
+	p := tea.NewProgram(model, opts...)
 	go watchFile(abs, p.Send)
 
 	if _, err := p.Run(); err != nil {
diff --git a/sections.go b/sections.go
index 6bb8628..6fdc01f 100644
--- a/sections.go
+++ b/sections.go
@@ -160,7 +160,7 @@ func entryStyleRules(sections []Section, bullet string) string {
 		}
 		b.WriteString(" until it needs a decision, and then the `Next:` line asks for that decision.\n")
 	}
-	b.WriteString("\nAn entry asks a quick question with an indented `Ask: yes | no` line — options separated by `|`, any words, emoji welcome (`Ask: ✅ Done | ❌ No`); the viewer draws each option as a button — or no options, for an open question the human answers in their own words. The human answers in the viewer, and an `Answer:` line appears under it; read it on your next turn, act on it, then move the item out of its section or drop the `Ask:` and `Answer:` pair so it stops asking. A `- [ ]` checklist item works the same way — the human ticks it, and it reads `- [x]`.\n")
+	b.WriteString("\nWhen a turn ends, leave its result as an entry and, under it, an indented `Ask:` line with one narrative question — \"what did you change on your side?\", \"how did the deploy go?\" — never a yes/no. Every open entry shows the human a `[ ✅ Done ]` and a `[ 💬 Reply ]` button; a reply lands under the entry as an `Answer:` line, and `✅ Done` moves it to Done with `Answer: ✅ Done`. Sidecar's hook reports the reply after your next tool call, so read it, act on it, then clear the `Ask:` and `Answer:` lines or move the entry. Choices are optional: `Ask: ✅ Go | ❌ Hold` draws a button for each.\n")
 	return b.String()
 }
 
diff --git a/semdiff.go b/semdiff.go
index b67bb57..b664b89 100644
--- a/semdiff.go
+++ b/semdiff.go
@@ -66,7 +66,7 @@ func semanticDiff(old, new Board) []string {
 		ot, nt := sectionTag(o.section), sectionTag(n.section)
 		switch {
 		case ot != nt:
-			moved = append(moved, fmt.Sprintf("moved %s→%s: %q", ot, nt, title(n.item.Key)))
+			moved = append(moved, fmt.Sprintf("moved %s→%s: %q%s", ot, nt, title(n.item.Key), humanChange(o.item, n.item)))
 		case o.item.Raw != n.item.Raw:
 			edited = append(edited, fmt.Sprintf("edited %s: %q%s", nt, title(n.item.Key), humanChange(o.item, n.item)))
 		}
@@ -374,7 +374,7 @@ func humanChange(old, new BoardItem) string {
 		out += " — unticked"
 	}
 	if a := answerOf(new); a != answerOf(old) && a != "" {
-		out += fmt.Sprintf(" — answered %q", a)
+		out += fmt.Sprintf(" — replied %q", truncateRunes(a, 400))
 	}
 	return out
 }
@@ -382,3 +382,10 @@ func humanChange(old, new BoardItem) string {
 func isTicked(it BoardItem) bool {
 	return strings.HasPrefix(strings.ToLower(firstLine(it.Raw)), ticked)
 }
+
+func truncateRunes(s string, n int) string {
+	if r := []rune(s); len(r) > n {
+		return string(r[:n]) + "…"
+	}
+	return s
+}
diff --git a/ui.go b/ui.go
index 012d42f..e974288 100644
--- a/ui.go
+++ b/ui.go
@@ -320,7 +320,7 @@ func (m *model) reload(force bool) (changed bool) {
 	}
 	displayRaw := raw
 	if boardOK {
-		displayRaw = applyCollapse(buttonize(raw, board), board, m.collapsed)
+		displayRaw = displayText(raw, board, m.collapsed)
 	}
 
 	rendered, err := renderMarkdown(displayRaw, m.renderWidth(), true)
@@ -333,7 +333,7 @@ func (m *model) reload(force bool) (changed bool) {
 		m.hasBaseline = false
 		return false
 	}
-	lines := strings.Split(rendered, "\n")
+	lines := styleButtons(strings.Split(rendered, "\n"))
 	m.headerLines = sectionHeaderLines(lines)
 	m.itemStarts = itemStartLines(lines, m.headerLines, m.board)
 	m.fixItemCursor()
@@ -347,10 +347,10 @@ func (m *model) reload(force bool) (changed bool) {
 		// a live viewer setting, not a property of any one file revision.
 		baseDisplay := m.prevBaseline
 		if baseBoard, ok := parseBoard(m.prevBaseline); ok {
-			baseDisplay = applyCollapse(buttonize(m.prevBaseline, baseBoard), baseBoard, m.collapsed)
+			baseDisplay = displayText(m.prevBaseline, baseBoard, m.collapsed)
 		}
 		if base, berr := renderMarkdown(baseDisplay, m.renderWidth(), true); berr == nil {
-			changedMap = changedLines(strings.Split(base, "\n"), lines)
+			changedMap = changedLines(styleButtons(strings.Split(base, "\n")), lines)
 		}
 	}
 	m.renderedLines = lines
@@ -393,12 +393,12 @@ func (m *model) rerenderCollapse() {
 	if !m.ready || m.fileMissing || m.loadErr != nil || len(m.board.Sections) == 0 {
 		return
 	}
-	displayRaw := applyCollapse(buttonize(m.raw, m.board), m.board, m.collapsed)
+	displayRaw := displayText(m.raw, m.board, m.collapsed)
 	rendered, err := renderMarkdown(displayRaw, m.renderWidth(), true)
 	if err != nil {
 		return // m.raw already rendered fine on the last successful reload
 	}
-	m.renderedLines = strings.Split(rendered, "\n")
+	m.renderedLines = styleButtons(strings.Split(rendered, "\n"))
 	m.headerLines = sectionHeaderLines(m.renderedLines)
 	m.itemStarts = itemStartLines(m.renderedLines, m.headerLines, m.board)
 	m.fixItemCursor()

From 61fd25abbfa3876534c194722126672ed00fd263 Mon Sep 17 00:00:00 2001
From: Than Tibbetts <than@broomfitters.com>
Date: Tue, 29 Sep 2026 15:00:30 -0400
Subject: [PATCH 06/11] Describe Ask: as a narrative question in the entry
 shape

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 sections.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sections.go b/sections.go
index 6fdc01f..2270732 100644
--- a/sections.go
+++ b/sections.go
@@ -146,7 +146,7 @@ func entryStyleRules(sections []Section, bullet string) string {
 		"two sentences of detail — more belongs in the PR or issue you link",
 		"bare URLs, each on its own line",
 		"one `Next:` line naming the single next action",
-		"optionally an indented `Ask:` line with options separated by `|`, which the human answers with an `Answer:` line",
+		"optionally an indented `Ask:` line with one narrative question, which the human answers with an `Answer:` line",
 		"entry text on one line — never hard-wrap; the viewer wraps to the pane and source newlines become visible breaks",
 	} {
 		b.WriteString(bullet + r + "\n")

From 3a3577761b955fc3ad24382be4fc156639051d02 Mon Sep 17 00:00:00 2001
From: Than Tibbetts <than@broomfitters.com>
Date: Tue, 29 Sep 2026 15:11:07 -0400
Subject: [PATCH 07/11] Quiet the buttons, undo viewer writes, and type replies
 inline

Buttons rest as grey blocks and turn solid under the pointer. They are drawn
after rendering, on their own line, so glamour can neither fuse a row onto an
item's last line nor wrap one mid-label; a test now clicks every button at
pane widths from 24 to 200. Reply is typed under its item. u, or a click on the
status message, undoes the last write, and refuses if the file changed since.
Every click reports its outcome in the status bar.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 README.md                                     |   2 +-
 buttons.go                                    | 176 ++++++++++----
 buttons_test.go                               | 226 +++++++++++++++---
 ...6-09-29-interactive-line-updates-design.md |   7 +-
 interact.go                                   | 184 +++++++++++---
 main.go                                       |   3 +-
 ui.go                                         |  44 +++-
 7 files changed, 519 insertions(+), 123 deletions(-)

diff --git a/README.md b/README.md
index e6ec952..1682f69 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ Boards are per-directory. `sidecar init` refuses a board that is a symlink — t
 
 - Renders Markdown with [glamour] and re-renders the moment the file changes. Sidecar watches the parent directory with fsnotify and a 100-millisecond debounce, so it handles atomic rename-swaps, deletes, and recreates — and waits quietly when the file doesn’t exist yet.
 - Scrolls with `j` and `k`, the arrow keys, `PgUp` and `PgDn`, and `g` and `G` for top and bottom, or with the mouse wheel. Sidecar keeps your scroll position across reloads.
-- Talks back to the agent. Under every open item the viewer draws two buttons, `[ ✅ Done ]` and `[ 💬 Reply ]`. Click Reply, type in your own words, and press Enter: your reply lands under the item as an `Answer:` line, and `sidecar`'s hook hands it to the agent after its next tool call — no chat message needed. Done moves the item to ✅ Done. An agent that wants something from you writes an indented `Ask:` line with a narrative question, which shows as `💬 …` above the buttons; `Ask: ✅ Go | ❌ Hold` draws a button per choice instead.
+- Talks back to the agent. Under every open item the viewer draws two quiet grey buttons, `[ ✅ Done ]` and `[ 💬 Reply ]`, that turn solid when the pointer is over one. Click Reply, type in your own words right under the item, and press Enter: your reply lands under the item as an `Answer:` line, and `sidecar`'s hook hands it to the agent after its next tool call — no chat message needed. Done moves the item to ✅ Done. `u` — or a click on the status-bar message — undoes the last change made from the viewer, and refuses if the agent has edited the board since. An agent that wants something from you writes an indented `Ask:` line with a narrative question, which shows as `💬 …` above the buttons; `Ask: ✅ Go | ❌ Hold` draws a button per choice instead.
 - Clicks work by default — buttons, checkboxes, items, and section headers. Mouse capture costs the terminal's plain drag-to-select: hold Shift (Option in iTerm2) to select anyway, press `M` to switch capture off and on, or start with `--no-mouse`. Everything also has a key: `]` and `[` select an item, `a` replies, `x` ticks a `- [ ]` item, `d` sends an item to Done, `1`–`9` pick a choice, `}` and `{` jump between open questions, and `esc` deselects.
 - `Tab` and `Shift+Tab` move a cursor between sections; `Enter` or `Space` collapses or expands the section under it. `✅ Done` and `📦 Shipped` start collapsed — every heading shows its item count, e.g. `✅ Done (12)`.
 - Reloads on demand with `r`, and quits with `q`.
diff --git a/buttons.go b/buttons.go
index cdcb61d..5b898bb 100644
--- a/buttons.go
+++ b/buttons.go
@@ -8,6 +8,9 @@
 // moves the item to ✅ Done. An "Ask: a | b" line draws its choices as
 // buttons of their own; a narrative "Ask: what did you change?" line shows as
 // the question the reply answers. Clicking any button needs no item selected.
+//
+// The rows are drawn after rendering, not written into the markdown: see
+// addButtonRows.
 package main
 
 import (
@@ -29,7 +32,10 @@ var (
 			Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#7AA2F7"))
 	buttonGoStyle = lipgloss.NewStyle().Bold(true).
 			Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#9ECE6A"))
-	chipRun = regexp.MustCompile(`\[ [^\]]+ \]`)
+	buttonRestStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#8B93A5")).Background(lipgloss.Color("#2B303B"))
+	buttonChosenStyle = lipgloss.NewStyle().Bold(true).
+				Foreground(lipgloss.Color("#9ECE6A")).Background(lipgloss.Color("#2B303B"))
 	countIn = regexp.MustCompile(` \(\d+\)$`)
 )
 
@@ -74,24 +80,17 @@ func replyChipFor(it BoardItem) string {
 // rowChips are the buttons under an item, in order.
 func rowChips(it BoardItem) []string { return []string{doneChip, replyChipFor(it)} }
 
-func codeSpans(chips []string) string {
-	spans := make([]string, len(chips))
-	for i, c := range chips {
-		spans[i] = "`" + c + "`"
-	}
-	return strings.Join(spans, " ")
-}
-
-// buttonize adds each open item's action row and redraws its Ask: line. It
-// may add lines, so run it on the text that will actually be rendered, after
-// applyCollapse; board must be parseBoard of that same text.
+// buttonize redraws each open item's Ask: line: a narrative question shows as
+// "💬 <question>", and a choice line ("Ask: a | b") as "💬 Choose:" — its
+// choices become buttons in the row below the item. The line count never
+// changes; the rows themselves are added after rendering (addButtonRows),
+// because glamour fuses any paragraph added under a list item onto its last
+// line and would wrap a button mid-label.
 func buttonize(raw string, board Board) string {
 	lines := strings.Split(raw, "\n")
-	replace := map[int]string{}
-	after := map[int]string{}
 	for _, s := range board.Sections {
 		for _, it := range s.Items {
-			if !actionable(s.Label, it) {
+			if !actionable(s.Label, it) || !hasAsk(it) {
 				continue
 			}
 			for i := it.StartLine + 1; i <= it.EndLine && i < len(lines); i++ {
@@ -99,27 +98,108 @@ func buttonize(raw string, board Board) string {
 					continue
 				}
 				indent := lines[i][:len(lines[i])-len(strings.TrimLeft(lines[i], " \t"))]
-				if opts := optionChips(it); len(opts) > 0 {
-					replace[i] = indent + codeSpans(opts)
-				} else if q := askText(it); q != "" {
-					replace[i] = indent + "💬 " + q
+				if q := askText(it); q != "" {
+					lines[i] = indent + "💬 " + q
+				} else {
+					lines[i] = indent + "💬 Choose:"
 				}
 				break
 			}
-			after[it.EndLine] = "  " + codeSpans(rowChips(it))
+		}
+	}
+	return strings.Join(lines, "\n")
+}
+
+// renderBoardLines renders the display markdown and adds every open item's
+// button row. board must be the parse of the file the display text came from,
+// so items line up with the rendered bullets.
+func renderBoardLines(display string, board Board, width int) ([]string, error) {
+	rendered, err := renderMarkdown(display, width, true)
+	if err != nil {
+		return nil, err
+	}
+	lines := strings.Split(rendered, "\n")
+	if len(board.Sections) == 0 {
+		return lines, nil
+	}
+	starts := itemStartLines(lines, sectionHeaderLines(lines), board)
+	return addButtonRows(lines, starts, board, width), nil
+}
+
+// addButtonRows inserts, below the last line of each mapped open item, its
+// buttons — choices first, then Done and Reply — packed to the pane width. An
+// item whose section could not be mapped to rendered lines gets none.
+func addButtonRows(lines []string, starts [][]int, board Board, width int) []string {
+	insert := map[int][]string{}
+	for si, s := range board.Sections {
+		if si >= len(starts) {
+			break
+		}
+		for ii, it := range s.Items {
+			if ii >= len(starts[si]) || !actionable(s.Label, it) {
+				continue
+			}
+			end := starts[si][ii] + 1
+			if ii+1 < len(starts[si]) {
+				end = starts[si][ii+1]
+			} else {
+				for end < len(lines) && strings.TrimSpace(stripANSI(lines[end])) != "" {
+					end++
+				}
+			}
+			// Back up over blank lines so the row hugs the item's last text.
+			for end-1 > starts[si][ii] && strings.TrimSpace(stripANSI(lines[end-1])) == "" {
+				end--
+			}
+			insert[end] = packButtons(append(optionChips(it), rowChips(it)...), width)
 		}
 	}
 	var out []string
 	for i, ln := range lines {
-		if r, ok := replace[i]; ok {
-			ln = r
-		}
+		out = append(out, insert[i]...)
 		out = append(out, ln)
-		if row, ok := after[i]; ok {
-			out = append(out, row)
+	}
+	return append(out, insert[len(lines)]...)
+}
+
+// packButtons lays styled buttons into lines no wider than width, two spaces
+// apart and indented two; a button that does not fit starts the next line.
+func packButtons(chips []string, width int) []string {
+	const indent = "  "
+	var rows []string
+	cur, curW := indent, len(indent)
+	for _, c := range chips {
+		w := visibleWidth(c)
+		if curW > len(indent) && curW+2+w > width {
+			rows = append(rows, cur)
+			cur, curW = indent, len(indent)
+		}
+		if curW > len(indent) {
+			cur += "  "
+			curW += 2
 		}
+		cur += styleChip(c)
+		curW += w
+	}
+	return append(rows, cur)
+}
+
+// styleChip paints one button at rest: a quiet grey block, so a screen of
+// items is not a screen of color. A recorded choice keeps its green text.
+func styleChip(c string) string {
+	if strings.HasPrefix(c, "[ ✓ ") {
+		return buttonChosenStyle.Render(c)
 	}
-	return strings.Join(out, "\n")
+	return buttonRestStyle.Render(c)
+}
+
+// hotChip paints a button under the pointer: solid green for Done, blue for
+// the rest.
+func hotChip(c string) string {
+	if c == doneChip || strings.HasPrefix(c, "[ ✓ ") {
+		return buttonGoStyle.Render(c)
+	}
+	return buttonStyle.Render(c)
 }
 
 // displayText is the board as rendered: collapsed sections dropped and counts
@@ -132,33 +212,6 @@ func displayText(raw string, board Board, collapsed map[string]bool) string {
 	return collapsedRaw
 }
 
-// styleButtons repaints every line made only of buttons with solid colors —
-// blue, and green for Done and a recorded choice — so they read as controls
-// rather than inline code. Visible text is unchanged, so chipAt still finds
-// each button's columns.
-func styleButtons(lines []string) []string {
-	out := make([]string, len(lines))
-	for i, ln := range lines {
-		out[i] = ln
-		t := stripANSI(ln)
-		body := strings.TrimSpace(t)
-		if !strings.HasPrefix(body, "[ ") || strings.TrimSpace(chipRun.ReplaceAllString(body, "")) != "" {
-			continue
-		}
-		indent := t[:len(t)-len(strings.TrimLeft(t, " "))]
-		var parts []string
-		for _, c := range chipRun.FindAllString(body, -1) {
-			if c == doneChip || strings.HasPrefix(c, "[ ✓ ") {
-				parts = append(parts, buttonGoStyle.Render(c))
-			} else {
-				parts = append(parts, buttonStyle.Render(c))
-			}
-		}
-		out[i] = indent + strings.Join(parts, "  ")
-	}
-	return out
-}
-
 // normalizeOption reduces an option to its letters and digits, lowercase,
 // so "✅ Done" answers to d and "👍 Yes" to y.
 func normalizeOption(o string) string {
@@ -204,3 +257,20 @@ func chipAt(it BoardItem, renderedLine string, x int) (kind chipKind, option str
 	}
 	return 0, "", false
 }
+
+// chipTextAt is chipAt's twin for hover: the text of the button covering
+// display column x, so it can be found again in the rendered line.
+func chipTextAt(it BoardItem, renderedLine string, x int) (string, bool) {
+	text := stripANSI(renderedLine)
+	for _, c := range append(optionChips(it), rowChips(it)...) {
+		idx := strings.Index(text, c)
+		if idx < 0 {
+			continue
+		}
+		col := visibleWidth(text[:idx])
+		if x >= col && x < col+visibleWidth(c) {
+			return c, true
+		}
+	}
+	return "", false
+}
diff --git a/buttons_test.go b/buttons_test.go
index 1643e85..e0922e0 100644
--- a/buttons_test.go
+++ b/buttons_test.go
@@ -6,6 +6,8 @@ import (
 	"testing"
 
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/muesli/termenv"
 )
 
 const buttonBoard = `# Board
@@ -28,30 +30,50 @@ func buttonModel(t *testing.T) (model, string) {
 	return testModel(t, p), p
 }
 
-func TestEveryOpenItemGetsAnActionRowBelowIt(t *testing.T) {
-	raw := "## 🧠 Needs you\n\n- plain\n- has detail\n  more\n\n## ✅ Done\n\n- finished\n"
+// plainLines renders a board the way the viewer does and strips the color.
+func plainLines(t *testing.T, raw string, collapsed map[string]bool, width int) []string {
+	t.Helper()
 	b, _ := parseBoard(raw)
-	got := buttonize(raw, b)
-	row := "  `[ ✅ Done ]` `[ 💬 Reply ]`"
-	if strings.Count(got, row) != 2 {
-		t.Fatalf("want a row under each of the 2 open items, none under Done:\n%s", got)
+	lines, err := renderBoardLines(displayText(raw, b, collapsed), b, width)
+	if err != nil {
+		t.Fatal(err)
 	}
-	if !strings.Contains(got, "- plain\n"+row+"\n- has detail\n  more\n"+row+"\n") {
-		t.Fatalf("rows must sit directly below their item:\n%s", got)
+	for i := range lines {
+		lines[i] = strings.TrimRight(stripANSI(lines[i]), " ")
 	}
+	return lines
 }
 
+func TestEveryOpenItemGetsAnActionRowBelowIt(t *testing.T) {
+	raw := "## 🧠 Needs you\n\n- plain\n- has detail\n  more\n\n## ✅ Done\n\n- finished\n"
+	got := plainLines(t, raw, nil, 60)
+	var rows []int
+	for i, l := range got {
+		if strings.Contains(l, doneChip) {
+			rows = append(rows, i)
+		}
+	}
+	if len(rows) != 2 {
+		t.Fatalf("want a row under each of the 2 open items, none under Done:\n%s", strings.Join(got, "\n"))
+	}
+	if !strings.HasPrefix(got[rows[0]-1], "• plain") || !strings.HasPrefix(got[rows[1]-1], "more") {
+		t.Fatalf("rows must hug the last line of their item:\n%s", strings.Join(got, "\n"))
+	}
+	if !strings.Contains(got[rows[0]], "[ 💬 Reply ]") {
+		t.Fatalf("row %q lacks Reply", got[rows[0]])
+	}
+}
 func TestNoRowUnderDoneOrShippedOrPlaceholder(t *testing.T) {
 	raw := "## ✅ Done (1)\n\n- a\n\n## 📦 Shipped\n\n- b\n\n## 🚧 In progress\n\n- " + emptySectionPlaceholder + "\n"
 	b, _ := parseBoard(raw)
-	if got := buttonize(raw, b); strings.Contains(got, "Reply") {
+	if got := (buttonize(raw, b)); strings.Contains(got, "Reply") {
 		t.Fatalf("finished and placeholder items get no buttons:\n%s", got)
 	}
 }
 
 func TestNarrativeAskShowsAsTheQuestion(t *testing.T) {
 	b, _ := parseBoard(buttonBoard)
-	got := buttonize(buttonBoard, b)
+	got := (buttonize(buttonBoard, b))
 	if !strings.Contains(got, "  💬 What did you change on your side in the meantime?\n") || strings.Contains(got, "Ask:") {
 		t.Fatalf("question not shown:\n%s", got)
 	}
@@ -62,37 +84,31 @@ func TestNarrativeAskShowsAsTheQuestion(t *testing.T) {
 
 func TestChoiceAskStillDrawsChoiceButtons(t *testing.T) {
 	raw := "## 🧠 Needs you\n\n- Merge?\n  Ask: ✅ Go | ❌ Hold\n"
-	b, _ := parseBoard(raw)
-	got := buttonize(raw, b)
-	if !strings.Contains(got, "  `[ ✅ Go ]` `[ ❌ Hold ]`\n") {
+	got := strings.Join(plainLines(t, raw, nil, 80), "\n")
+	if !strings.Contains(got, "[ ✅ Go ]") || !strings.Contains(got, "[ ❌ Hold ]") || !strings.Contains(got, "💬 Choose:") {
 		t.Fatalf("choices missing:\n%s", got)
 	}
-	raw2 := strings.Replace(raw, "Ask:", "Answer: ❌ Hold\n  Ask:", 1)
-	b2, _ := parseBoard(raw2)
-	if got := buttonize(raw2, b2); !strings.Contains(got, "`[ ✓ ❌ Hold ]`") {
+	raw2 := strings.Replace(raw, "  Ask:", "  Answer: ❌ Hold\n  Ask:", 1)
+	if got := strings.Join(plainLines(t, raw2, nil, 80), "\n"); !strings.Contains(got, "[ ✓ ❌ Hold ]") {
 		t.Fatalf("recorded choice not ticked:\n%s", got)
 	}
 }
-
 func TestReplyButtonReadsEditOnceReplied(t *testing.T) {
 	raw := "## 🧠 Needs you\n\n- x\n  Answer: did it\n"
-	b, _ := parseBoard(raw)
-	if got := buttonize(raw, b); !strings.Contains(got, "`[ 💬 Edit reply ]`") {
+	if got := strings.Join(plainLines(t, raw, nil, 60), "\n"); !strings.Contains(got, "[ 💬 Edit reply ]") {
 		t.Fatalf("got:\n%s", got)
 	}
 }
-
-func TestDisplayTextSurvivesCollapseCounts(t *testing.T) {
+func TestCollapsedSectionsKeepTheirCountAndDropTheirButtons(t *testing.T) {
 	m, _ := buttonModel(t)
-	got := displayText(m.raw, m.board, map[string]bool{"✅ Done": true})
-	if !strings.Contains(got, "## ✅ Done (1)") || strings.Count(got, "[ ✅ Done ]") != 1 {
+	got := strings.Join(plainLines(t, m.raw, map[string]bool{"✅ Done": true}, 60), "\n")
+	if !strings.Contains(got, "✅ Done (1)") || strings.Count(got, doneChip) != 1 {
 		t.Fatalf("got:\n%s", got)
 	}
 }
-
 func TestButtonsRenderInThePane(t *testing.T) {
 	m, _ := buttonModel(t)
-	view := stripANSI(m.vp.View())
+	view := (stripANSI(m.vp.View()))
 	for _, want := range []string{"[ ✅ Done ]", "[ 💬 Reply ]", "What did you change"} {
 		if !strings.Contains(view, want) {
 			t.Fatalf("pane missing %q:\n%s", want, view)
@@ -106,8 +122,9 @@ func TestButtonsRenderInThePane(t *testing.T) {
 func clickAt(t *testing.T, m model, text string, x int) model {
 	t.Helper()
 	for i, ln := range m.renderedLines {
-		if idx := strings.Index(stripANSI(ln), text); idx >= 0 {
-			msg := tea.MouseMsg{X: visibleWidth(stripANSI(ln)[:idx]) + x, Y: i - m.vp.YOffset, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft}
+		if plain := (stripANSI(ln)); strings.Contains(plain, text) {
+			idx := strings.Index(plain, text)
+			msg := tea.MouseMsg{X: visibleWidth(plain[:idx]) + x, Y: i - m.vp.YOffset, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft}
 			next, _ := m.Update(msg)
 			return next.(model)
 		}
@@ -238,3 +255,158 @@ func TestAKeyRepliesOnAnyItem(t *testing.T) {
 		t.Fatalf("got:\n%s", readFile(t, p))
 	}
 }
+
+const wideBoard = `# Board
+
+## 🧠 Needs you
+
+- PR #30 lets the human answer the agent from the board, with a long line that wraps at every pane width the test tries. It ends mid sentence so the button row cannot hide in slack space.
+  https://github.com/than/sidecar/pull/30
+  Ask: What did you change on your side while this ran, and did the deploy behave?
+  Next: review and merge.
+
+## 🚧 In progress
+
+- Short one.
+- Second short one with **bold** and a [link](https://example.com/a/long/path/that/keeps/going).
+
+## ✅ Done
+
+- shipped
+`
+
+// A button that wraps mid-label cannot be clicked, so at every pane width
+// each open item's buttons must sit whole on one rendered line, and a click
+// on them must act.
+func TestButtonsStayWholeAndClickableAtEveryWidth(t *testing.T) {
+	for w := 24; w <= 200; w += 7 {
+		p := filepath.Join(t.TempDir(), "sidecar.md")
+		writeFile(t, p, wideBoard)
+		m := newModel(p, false)
+		m.mouse = true
+		next, _ := m.Update(tea.WindowSizeMsg{Width: w, Height: 60})
+		m = next.(model)
+		rows := 0
+		for _, ln := range m.renderedLines {
+			plain := (stripANSI(ln))
+			if strings.Contains(plain, doneChip) {
+				rows++
+				if !strings.Contains(plain, replyChip) && w >= 30 {
+					t.Fatalf("width %d: Done and Reply split across lines: %q", w, plain)
+				}
+			}
+		}
+		if rows != 3 {
+			t.Fatalf("width %d: want 3 whole button rows, got %d\n%s", w, rows, stripANSI(strings.Join(m.renderedLines, "\n")))
+		}
+		m2 := clickAt(t, m, replyChip, 3)
+		if !m2.typing {
+			t.Fatalf("width %d: clicking Reply did nothing", w)
+		}
+		m3 := clickAt(t, m, doneChip, 3)
+		if m3.notice == "" && readFile(t, p) == wideBoard {
+			t.Fatalf("width %d: clicking Done did nothing", w)
+		}
+	}
+}
+
+func motionAt(t *testing.T, m model, text string, x int) model {
+	t.Helper()
+	for i, ln := range m.renderedLines {
+		if plain := stripANSI(ln); strings.Contains(plain, text) {
+			idx := strings.Index(plain, text)
+			next, _ := m.Update(tea.MouseMsg{X: visibleWidth(plain[:idx]) + x, Y: i - m.vp.YOffset, Action: tea.MouseActionMotion})
+			return next.(model)
+		}
+	}
+	t.Fatalf("no rendered line contains %q", text)
+	return m
+}
+
+func TestButtonsRestQuietAndPaintUnderThePointer(t *testing.T) {
+	prev := lipgloss.ColorProfile()
+	lipgloss.SetColorProfile(termenv.TrueColor)
+	t.Cleanup(func() { lipgloss.SetColorProfile(prev) })
+	m, _ := buttonModel(t)
+	m.mouse = true
+	rest := m.vp.View()
+	m = motionAt(t, m, replyChip, 3)
+	if m.hover.line < 0 || m.hover.chip != replyChip {
+		t.Fatalf("hover not tracked: %+v", m.hover)
+	}
+	if hot := m.vp.View(); hot == rest || !strings.Contains(hot, buttonStyle.Render(replyChip)) {
+		t.Fatal("the hovered button should repaint solid blue")
+	}
+	if strings.Contains(rest, buttonStyle.Render(replyChip)) || strings.Contains(rest, buttonGoStyle.Render(doneChip)) {
+		t.Fatal("buttons at rest must not be painted solid")
+	}
+	m = motionAt(t, m, "Next:", 0) // pointer leaves the buttons
+	if m.hover.line != -1 || m.vp.View() != rest {
+		t.Fatal("moving off a button should return it to rest")
+	}
+}
+
+func TestHoverIgnoredWithMouseOff(t *testing.T) {
+	m, _ := buttonModel(t)
+	m = motionAt(t, m, replyChip, 3)
+	if m.hover.line != -1 {
+		t.Fatal("no hover while mouse is off")
+	}
+}
+
+func TestUndoRestoresTheBoardAndRefusesAfterAgentEdits(t *testing.T) {
+	m, p := buttonModel(t)
+	m.mouse = true
+	m = clickAt(t, m, doneChip, 3)
+	if !strings.Contains(m.notice, "u to undo") {
+		t.Fatalf("notice %q should offer undo", m.notice)
+	}
+	m = press(t, m, "u")
+	if readFile(t, p) != buttonBoard || m.notice != "undone" {
+		t.Fatalf("undo did not restore the board (notice %q):\n%s", m.notice, readFile(t, p))
+	}
+	// Move again, then let the agent edit: undo must not clobber it.
+	m = clickAt(t, m, doneChip, 3)
+	writeFile(t, p, readFile(t, p)+"- agent added this\n")
+	m = press(t, m, "u")
+	if !strings.Contains(readFile(t, p), "- agent added this") || !strings.Contains(m.notice, "changed since") {
+		t.Fatalf("undo overwrote the agent's edit (notice %q)", m.notice)
+	}
+}
+
+func TestClickingTheStatusMessageUndoes(t *testing.T) {
+	m, p := buttonModel(t)
+	m.mouse = true
+	m = clickAt(t, m, doneChip, 3)
+	next, _ := m.Update(tea.MouseMsg{X: 5, Y: m.vp.Height, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft})
+	_ = next
+	if readFile(t, p) != buttonBoard {
+		t.Fatal("clicking the status bar should undo the last change")
+	}
+}
+
+func TestUKeyScrollsWhenNothingToUndo(t *testing.T) {
+	m, _ := buttonModel(t)
+	m = press(t, m, "u")
+	if m.notice != "" {
+		t.Fatalf("u with nothing to undo should fall through to the viewport, got %q", m.notice)
+	}
+}
+
+func TestReplyIsTypedInlineUnderTheItem(t *testing.T) {
+	m, _ := buttonModel(t)
+	m.mouse = true
+	m = clickAt(t, m, replyChip, 3)
+	m = typeText(t, m, "worker restarted")
+	view := stripANSI(m.vp.View())
+	if !strings.Contains(view, "💬 worker restarted▌") {
+		t.Fatalf("typed text should appear under the item:\n%s", view)
+	}
+	if strings.Contains(view, replyChip) {
+		t.Fatal("the typed line replaces the button row while typing")
+	}
+	m = special(t, m, tea.KeyEsc)
+	if v := stripANSI(m.vp.View()); !strings.Contains(v, replyChip) || strings.Contains(v, "worker restarted") {
+		t.Fatalf("esc should bring the buttons back:\n%s", v)
+	}
+}
diff --git a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
index 93f06fe..2b8d807 100644
--- a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
+++ b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
@@ -14,7 +14,8 @@ Under every open item — everything outside ✅ Done and 📦 Shipped — two b
 
     [ ✅ Done ]  [ 💬 Reply ]
 
-- **Reply** opens a free-text line in the status bar, pre-filled with the current reply. Enter writes `Answer: <text>` under the item, replacing an earlier one; esc abandons it. While typing, every key is text.
+- Buttons rest as quiet grey blocks and turn solid (green Done, blue the rest) under the pointer, so a screen of items stays calm. They are drawn after rendering, on their own line below each item.
+- **Reply** opens a free-text line under the item, where the button row was, pre-filled with the current reply. Enter writes `Answer: <text>` under the item, replacing an earlier one; esc abandons it. While typing, every key is text.
 - **Done** moves the item to ✅ Done. When the human has said nothing else it also writes `Answer: ✅ Done`, so the hook can tell a human finished it.
 - An `Ask:` line with no `|` is the question. It shows as `💬 <question>` above the buttons. An `Ask: a | b` line is a choice and draws one button per option; the recorded choice is ticked.
 
@@ -38,6 +39,10 @@ Plain markdown; the file never contains a button.
 
 `editItem` re-reads the file, finds the item by section label and exact text, applies a pure text transform, and swaps the file in by rename, keeping its mode. An agent edit elsewhere survives; if the item itself changed since it was rendered, nothing is written and the status bar says so.
 
+## Undo
+
+Every write made from the viewer is remembered with the file as it stood before and after. `u`, or a click on the status message, restores the earlier file — but only while the file still reads exactly as that write left it, so undo can never overwrite what the agent wrote since. Every click also says what it did in the status bar, so none looks ignored.
+
 ## Keyboard
 
 `]` / `[` select an item, `a` replies, `d` sends it to Done, `x` ticks, `1`–`9` and `y` / `n` / `d` pick a choice, `}` / `{` jump between unanswered questions, `esc` deselects. The status bar counts open questions.
diff --git a/interact.go b/interact.go
index fe7dfe3..eae8997 100644
--- a/interact.go
+++ b/interact.go
@@ -6,11 +6,28 @@ package main
 
 import (
 	"fmt"
+	"os"
 	"strings"
 
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
 )
 
+// typingStyle is the reply being typed under an item.
+var typingStyle = lipgloss.NewStyle().Bold(true).
+	Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#E5C07B"))
+
+// hoverChip is the button under the pointer: the rendered line and which
+// button's text. line is -1 when the pointer is on none.
+type hoverChip struct {
+	line int
+	chip string
+}
+
+// undoEntry is one write made from the viewer: the file before and after, so
+// undo can restore it only while the file still reads as we left it.
+type undoEntry struct{ before, after string }
+
 // itemStartLines maps each board item to the rendered line it starts on: a
 // top-level "• ", "□ ", or "✓ " line at column 0 between a section's header
 // and the next. A section whose rendered count disagrees with the parsed
@@ -184,6 +201,7 @@ func doneLabel(b Board) string {
 // apply writes one edit, then reloads so the pane shows the file as it now
 // is. A refused or failed write surfaces in the status bar.
 func (m *model) apply(label string, it BoardItem, fn func(string, Board, int, int) (string, error), note string) {
+	before, _ := os.ReadFile(m.path)
 	if err := editItem(m.path, label, it.Raw, fn); err != nil {
 		m.notice = err.Error()
 		if err == errBoardChanged {
@@ -191,10 +209,46 @@ func (m *model) apply(label string, it BoardItem, fn func(string, Board, int, in
 		}
 		return
 	}
+	after, _ := os.ReadFile(m.path)
+	if string(before) != string(after) {
+		m.undo = append(m.undo, undoEntry{string(before), string(after)})
+		if note == "" {
+			note = "ticked"
+		}
+		note += " — u to undo"
+	}
 	m.notice = note
 	m.reload(true)
 }
 
+// undoLast restores the file as it was before the viewer's last write — but
+// only while the file still reads exactly as that write left it, so undo can
+// never overwrite something the agent wrote since.
+func (m *model) undoLast() {
+	if len(m.undo) == 0 {
+		m.notice = "nothing to undo"
+		return
+	}
+	e := m.undo[len(m.undo)-1]
+	cur, err := os.ReadFile(m.path)
+	if err != nil || string(cur) != e.after {
+		m.undo = nil
+		m.notice = "board changed since — nothing undone"
+		return
+	}
+	if err := writeAtomic(m.path, e.before); err != nil {
+		m.notice = err.Error()
+		return
+	}
+	m.undo = m.undo[:len(m.undo)-1]
+	m.itemSec, m.itemIdx = -1, -1
+	m.notice = "undone"
+	if len(m.undo) > 0 {
+		m.notice += " — u to undo again"
+	}
+	m.reload(true)
+}
+
 // hint is the status-bar line shown while an item is selected.
 func (m model) hint() string {
 	it, _, ok := m.selected()
@@ -219,11 +273,38 @@ func (m model) hint() string {
 	return strings.Join(parts, " · ")
 }
 
-// mouseClick selects the item under a left click and, in the checkbox
-// gutter, ticks it. Only wired while mouse mode is on.
+// itemAtLine finds the mapped, real item whose rendered lines — first line
+// through its button row — include line.
+func (m model) itemAtLine(line int) (si, ii, start int, ok bool) {
+	for si, starts := range m.itemStarts {
+		for ii, start := range starts {
+			end := start + 1
+			if ii+1 < len(starts) {
+				end = starts[ii+1]
+			} else {
+				for end < len(m.renderedLines) && strings.TrimSpace(stripANSI(m.renderedLines[end])) != "" {
+					end++
+				}
+			}
+			if line >= start && line < end && m.board.Sections[si].Items[ii].Key != emptySectionPlaceholder {
+				return si, ii, start, true
+			}
+		}
+	}
+	return 0, 0, 0, false
+}
+
+// mouseClick acts on a left click: a section header collapses, a button
+// acts, a checkbox ticks, and any other spot on an item selects it. Every
+// outcome says so in the status bar, so a click never looks ignored.
 func (m *model) mouseClick(x, y int) {
+	if y == m.vp.Height && len(m.undo) > 0 {
+		m.undoLast() // the status bar carries "u to undo"
+		return
+	}
 	if y < 0 || y >= m.vp.Height {
-		return // the status bar row is not content
+		m.notice = fmt.Sprintf("click %d,%d — the status bar is not clickable", x, y)
+		return
 	}
 	line := y + m.vp.YOffset
 	for si, h := range m.headerLines {
@@ -233,43 +314,85 @@ func (m *model) mouseClick(x, y int) {
 			return
 		}
 	}
-	for si, starts := range m.itemStarts {
-		for ii, start := range starts {
-			end := start + 1
-			if ii+1 < len(starts) {
-				end = starts[ii+1]
-			} else {
-				for end < len(m.renderedLines) && strings.TrimSpace(stripANSI(m.renderedLines[end])) != "" {
-					end++
-				}
-			}
-			if line < start || line >= end || m.board.Sections[si].Items[ii].Key == emptySectionPlaceholder {
-				continue
+	si, ii, start, ok := m.itemAtLine(line)
+	if !ok {
+		m.notice = fmt.Sprintf("click %d,%d — nothing to click on that line", x, y)
+		return
+	}
+	m.itemSec, m.itemIdx, m.cursor = si, ii, si
+	m.recompose()
+	it, label, _ := m.selected()
+	switch kind, opt, hit := chipAt(it, m.renderedLines[line], x); {
+	case hit && kind == chipReply:
+		m.typing, m.input = true, answerOf(it)
+		m.recompose()
+	case hit && kind == chipDone:
+		m.apply(label, it, doneAndMove, "moved to Done")
+		m.itemSec, m.itemIdx = -1, -1
+	case hit:
+		m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, opt) }), "replied "+opt)
+	case x <= 1 && line == start && isCheckbox(it):
+		m.apply(label, it, replaceLines(toggleCheckbox), "")
+	default:
+		m.notice = fmt.Sprintf("click %d,%d — item selected; the buttons under it are the clickable part", x, y)
+	}
+}
+
+// setHover tracks the button under the pointer so it can be painted; it
+// re-renders only when the button changes.
+func (m *model) setHover(x, y int) {
+	next := hoverChip{line: -1}
+	if y >= 0 && y < m.vp.Height {
+		line := y + m.vp.YOffset
+		if si, ii, _, ok := m.itemAtLine(line); ok {
+			it := m.board.Sections[si].Items[ii]
+			if c, hit := chipTextAt(it, m.renderedLines[line], x); hit {
+				next = hoverChip{line: line, chip: c}
 			}
-			m.itemSec, m.itemIdx, m.cursor = si, ii, si
-			m.recompose()
-			it, label, _ := m.selected()
-			switch kind, opt, hit := chipAt(it, m.renderedLines[line], x); {
-			case hit && kind == chipReply:
-				m.typing, m.input = true, answerOf(it)
-			case hit && kind == chipDone:
-				m.apply(label, it, doneAndMove, "moved to Done")
-				m.itemSec, m.itemIdx = -1, -1
-			case hit:
-				m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, opt) }), "replied "+opt)
-			case x <= 1 && line == start && isCheckbox(it):
-				m.apply(label, it, replaceLines(toggleCheckbox), "")
+		}
+	}
+	if next != m.hover {
+		m.hover = next
+		m.recompose()
+	}
+}
+
+// typingRow returns the line that replaces the selected item's button row
+// while a reply is being typed, so the text appears where the click was.
+func (m model) typingRow(width int) (line int, text string, ok bool) {
+	if !m.typing {
+		return 0, "", false
+	}
+	si, ii, start, found := -1, -1, 0, false
+	if it, _, sel := m.selected(); sel {
+		_ = it
+		si, ii = m.itemSec, m.itemIdx
+		if m.itemSec < len(m.itemStarts) && m.itemIdx < len(m.itemStarts[m.itemSec]) {
+			start, found = m.itemStarts[si][ii], true
+		}
+	}
+	if !found {
+		return 0, "", false
+	}
+	for l := start; l < len(m.renderedLines); l++ {
+		if strings.Contains(stripANSI(m.renderedLines[l]), doneChip) {
+			room := max(4, width-8)
+			shown := m.input
+			for visibleWidth(shown) > room && shown != "" {
+				shown = string([]rune(shown)[1:])
 			}
-			return
+			return l, "  " + typingStyle.Render(" 💬 "+shown+"▌ "), true
 		}
 	}
+	return 0, "", false
 }
 
 func (m *model) toggleMouse() tea.Cmd {
 	m.mouse = !m.mouse
+	m.hover = hoverChip{line: -1}
 	if m.mouse {
 		m.notice = "mouse on — click buttons, boxes, items, headers (M to release)"
-		return tea.EnableMouseCellMotion
+		return tea.EnableMouseAllMotion
 	}
 	m.notice = "mouse off — native text selection restored (M to click again)"
 	return tea.DisableMouse
@@ -298,6 +421,7 @@ func (m *model) typeKey(msg tea.KeyMsg) {
 	case tea.KeyRunes:
 		m.input += string(msg.Runes)
 	}
+	m.recompose() // the reply is drawn under its item, so redraw on every key
 }
 
 // pendingQuestions counts unanswered Ask: items outside the finished
diff --git a/main.go b/main.go
index 8782619..3a6cc61 100644
--- a/main.go
+++ b/main.go
@@ -46,6 +46,7 @@ keys:  j/k, arrows, PgUp/PgDn, wheel        scroll
        M                                    mouse on/off. On by default: click the
                                               [ Done ] / [ Reply ] buttons, boxes, items,
                                               and section headers. Shift-drag selects text.
+       u                                    undo the last change made from the viewer
        q                                    quit
 
 The file doesn't have to exist yet — sidecar waits for it and renders the
@@ -124,7 +125,7 @@ func runViewer(abs string, noFlash, noMouse bool) int {
 	// without it and M toggles it while running.
 	if !noMouse {
 		model.mouse = true
-		opts = append(opts, tea.WithMouseCellMotion())
+		opts = append(opts, tea.WithMouseAllMotion())
 	}
 	p := tea.NewProgram(model, opts...)
 	go watchFile(abs, p.Send)
diff --git a/ui.go b/ui.go
index e974288..f1f86cd 100644
--- a/ui.go
+++ b/ui.go
@@ -90,12 +90,14 @@ type model struct {
 	itemStarts       [][]int
 	notice           string
 	mouse            bool
-	typing           bool   // an answer is being typed in the status bar
-	input            string // the answer typed so far
+	typing           bool   // a reply is being typed under the selected item
+	input            string // the reply typed so far
+	hover            hoverChip
+	undo             []undoEntry
 }
 
 func newModel(path string, noFlash bool) model {
-	return model{path: path, noFlash: noFlash, collapsed: map[string]bool{}, cursor: -1, itemSec: -1, itemIdx: -1}
+	return model{path: path, noFlash: noFlash, collapsed: map[string]bool{}, cursor: -1, itemSec: -1, itemIdx: -1, hover: hoverChip{line: -1}}
 }
 
 func (m model) Init() tea.Cmd {
@@ -109,7 +111,12 @@ func tick() tea.Cmd {
 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case tea.MouseMsg:
+		if m.mouse && msg.Action == tea.MouseActionMotion {
+			m.setHover(msg.X, msg.Y)
+			return m, nil
+		}
 		if m.mouse && msg.Action == tea.MouseActionPress && msg.Button == tea.MouseButtonLeft {
+			m.notice = fmt.Sprintf("click %d,%d", msg.X, msg.Y) // proof the click arrived, if nothing acts on it
 			m.mouseClick(msg.X, msg.Y)
 			return m, nil
 		}
@@ -138,6 +145,11 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		case "{":
 			m.moveQuestionCursor(-1)
 			return m, nil
+		case "u":
+			if len(m.undo) > 0 {
+				m.undoLast()
+				return m, nil
+			}
 		case "M":
 			return m, m.toggleMouse()
 		case "esc":
@@ -323,7 +335,7 @@ func (m *model) reload(force bool) (changed bool) {
 		displayRaw = displayText(raw, board, m.collapsed)
 	}
 
-	rendered, err := renderMarkdown(displayRaw, m.renderWidth(), true)
+	lines, err := renderBoardLines(displayRaw, m.board, m.renderWidth())
 	if err != nil {
 		m.loadErr = err
 		m.vp.SetContent(fmt.Sprintf("\n  Render error: %v", err))
@@ -333,7 +345,6 @@ func (m *model) reload(force bool) (changed bool) {
 		m.hasBaseline = false
 		return false
 	}
-	lines := styleButtons(strings.Split(rendered, "\n"))
 	m.headerLines = sectionHeaderLines(lines)
 	m.itemStarts = itemStartLines(lines, m.headerLines, m.board)
 	m.fixItemCursor()
@@ -349,8 +360,9 @@ func (m *model) reload(force bool) (changed bool) {
 		if baseBoard, ok := parseBoard(m.prevBaseline); ok {
 			baseDisplay = displayText(m.prevBaseline, baseBoard, m.collapsed)
 		}
-		if base, berr := renderMarkdown(baseDisplay, m.renderWidth(), true); berr == nil {
-			changedMap = changedLines(styleButtons(strings.Split(base, "\n")), lines)
+		baseBoard, _ := parseBoard(m.prevBaseline)
+		if base, berr := renderBoardLines(baseDisplay, baseBoard, m.renderWidth()); berr == nil {
+			changedMap = changedLines(base, lines)
 		}
 	}
 	m.renderedLines = lines
@@ -368,7 +380,19 @@ func (m *model) reload(force bool) (changed bool) {
 // changed/flash marking (composeMarked) and the section-cursor highlight
 // (applyCursorHighlight) — at the current flash and cursor state.
 func (m *model) compose() string {
-	display := composeMarked(m.renderedLines, m.changed, m.lineFlash && !m.noFlash, m.renderWidth())
+	lines := m.renderedLines
+	// Overlays that swap whole lines work on a copy, before any tint is
+	// layered on: the hovered button turns solid, and a reply being typed
+	// replaces its item's button row.
+	if m.hover.line >= 0 && m.hover.line < len(lines) {
+		lines = append([]string(nil), lines...)
+		lines[m.hover.line] = strings.Replace(lines[m.hover.line], styleChip(m.hover.chip), hotChip(m.hover.chip), 1)
+	}
+	if l, text, ok := m.typingRow(m.renderWidth()); ok && l < len(lines) {
+		lines = append([]string(nil), lines...)
+		lines[l] = text
+	}
+	display := composeMarked(lines, m.changed, m.lineFlash && !m.noFlash, m.renderWidth())
 	display = applyCursorHighlight(display, m.headerLines, m.cursor, m.renderWidth())
 	return applyItemHighlight(display, m.itemStarts, m.itemSec, m.itemIdx, 0, m.renderWidth())
 }
@@ -394,11 +418,11 @@ func (m *model) rerenderCollapse() {
 		return
 	}
 	displayRaw := displayText(m.raw, m.board, m.collapsed)
-	rendered, err := renderMarkdown(displayRaw, m.renderWidth(), true)
+	lines, err := renderBoardLines(displayRaw, m.board, m.renderWidth())
 	if err != nil {
 		return // m.raw already rendered fine on the last successful reload
 	}
-	m.renderedLines = styleButtons(strings.Split(rendered, "\n"))
+	m.renderedLines = lines
 	m.headerLines = sectionHeaderLines(m.renderedLines)
 	m.itemStarts = itemStartLines(m.renderedLines, m.headerLines, m.board)
 	m.fixItemCursor()

From 98e49d03ada13e8859a7632c8dc31b2e56f8876f Mon Sep 17 00:00:00 2001
From: Than Tibbetts <than@broomfitters.com>
Date: Tue, 29 Sep 2026 15:18:22 -0400
Subject: [PATCH 08/11] Space items one blank line apart, draw resting buttons
 with no background

A blank line now separates every item, buttons rest as grey text and get a
background only under the pointer, and the reply line says how to send it.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 buttons.go      | 38 +++++++++++++++++++++++------
 buttons_test.go | 63 +++++++++++++++++++++++++++++++++++++++++++++++++
 interact.go     | 17 ++++++++++++-
 3 files changed, 110 insertions(+), 8 deletions(-)

diff --git a/buttons.go b/buttons.go
index 5b898bb..eb384b6 100644
--- a/buttons.go
+++ b/buttons.go
@@ -32,11 +32,9 @@ var (
 			Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#7AA2F7"))
 	buttonGoStyle = lipgloss.NewStyle().Bold(true).
 			Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#9ECE6A"))
-	buttonRestStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.Color("#8B93A5")).Background(lipgloss.Color("#2B303B"))
-	buttonChosenStyle = lipgloss.NewStyle().Bold(true).
-				Foreground(lipgloss.Color("#9ECE6A")).Background(lipgloss.Color("#2B303B"))
-	countIn = regexp.MustCompile(` \(\d+\)$`)
+	buttonRestStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("#8B93A5"))
+	buttonChosenStyle = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("#9ECE6A"))
+	countIn           = regexp.MustCompile(` \(\d+\)$`)
 )
 
 // finishedLabel reports a ✅ Done or 📦 Shipped heading, with or without the
@@ -154,6 +152,32 @@ func addButtonRows(lines []string, starts [][]int, board Board, width int) []str
 			insert[end] = packButtons(append(optionChips(it), rowChips(it)...), width)
 		}
 	}
+	// One blank line between items keeps a long list from reading as a wall:
+	// after each item (and its buttons) whose next line is not already blank.
+	for si, s := range board.Sections {
+		if si >= len(starts) {
+			break
+		}
+		for ii := range s.Items {
+			if ii >= len(starts[si]) {
+				continue
+			}
+			end := starts[si][ii] + 1
+			if ii+1 < len(starts[si]) {
+				end = starts[si][ii+1]
+			} else {
+				for end < len(lines) && strings.TrimSpace(stripANSI(lines[end])) != "" {
+					end++
+				}
+			}
+			for end-1 > starts[si][ii] && strings.TrimSpace(stripANSI(lines[end-1])) == "" {
+				end--
+			}
+			if end < len(lines) && strings.TrimSpace(stripANSI(lines[end])) != "" {
+				insert[end] = append(insert[end], "")
+			}
+		}
+	}
 	var out []string
 	for i, ln := range lines {
 		out = append(out, insert[i]...)
@@ -184,8 +208,8 @@ func packButtons(chips []string, width int) []string {
 	return append(rows, cur)
 }
 
-// styleChip paints one button at rest: a quiet grey block, so a screen of
-// items is not a screen of color. A recorded choice keeps its green text.
+// styleChip paints one button at rest: grey text on no background, so a
+// screen of items is not a screen of color. A recorded choice keeps its green text.
 func styleChip(c string) string {
 	if strings.HasPrefix(c, "[ ✓ ") {
 		return buttonChosenStyle.Render(c)
diff --git a/buttons_test.go b/buttons_test.go
index e0922e0..f988a70 100644
--- a/buttons_test.go
+++ b/buttons_test.go
@@ -410,3 +410,66 @@ func TestReplyIsTypedInlineUnderTheItem(t *testing.T) {
 		t.Fatalf("esc should bring the buttons back:\n%s", v)
 	}
 }
+
+func TestOneBlankLineSeparatesItems(t *testing.T) {
+	raw := "## 🧠 Needs you\n\n- first\n- second\n  more\n- third\n\n## ✅ Done\n\n- a\n- b\n"
+	got := plainLines(t, raw, nil, 60)
+	text := strings.Join(got, "\n")
+	for _, pair := range [][2]string{{"• first", "• second"}, {"more", "• third"}} {
+		a, b := strings.Index(text, pair[0]), strings.Index(text, pair[1])
+		between := text[a:b]
+		if !strings.Contains(between, "\n\n") || strings.Contains(between, "\n\n\n") {
+			t.Fatalf("want exactly one blank line between %q and %q, got %q\n%s", pair[0], pair[1], between, text)
+		}
+	}
+	if strings.Contains(text, "\n\n\n") {
+		t.Fatalf("no run of blank lines anywhere:\n%s", text)
+	}
+	// Finished items are spaced too.
+	if a, b := strings.Index(text, "• a"), strings.Index(text, "• b"); !strings.Contains(text[a:b], "\n\n") {
+		t.Fatalf("Done items should be spaced:\n%s", text)
+	}
+}
+
+func TestSpacerDoesNotBreakClickingOrSelection(t *testing.T) {
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, "## 🧠 Needs you\n\n- first\n- second\n\n## ✅ Done\n\n- old\n")
+	m := testModel(t, p)
+	m.mouse = true
+	m = clickAt(t, m, doneChip, 3) // first row's Done
+	b, _ := parseBoard(readFile(t, p))
+	if len(b.Sections[0].Items) != 1 || b.Sections[0].Items[0].Key != "second" {
+		t.Fatalf("clicked the wrong item's Done:\n%s", readFile(t, p))
+	}
+	m = press(t, m, "]", "]") // items still map one-to-one with spacers present
+	if it, _, ok := m.selected(); !ok || it.Key != "second" {
+		t.Fatalf("selection lost with spacers in the layout")
+	}
+}
+
+func TestButtonsHaveNoBackgroundAtRest(t *testing.T) {
+	prev := lipgloss.ColorProfile()
+	lipgloss.SetColorProfile(termenv.TrueColor)
+	t.Cleanup(func() { lipgloss.SetColorProfile(prev) })
+	for _, c := range []string{doneChip, replyChip, chipText("Go", true), chipText("Go", false)} {
+		if strings.Contains(styleChip(c), "48;") {
+			t.Fatalf("%q paints a background at rest: %q", c, styleChip(c))
+		}
+	}
+	if !strings.Contains(hotChip(replyChip), "48;") || !strings.Contains(hotChip(doneChip), "48;") {
+		t.Fatal("hovered buttons should paint a background")
+	}
+}
+
+func TestTypingRowHintsHowToSend(t *testing.T) {
+	m, _ := buttonModel(t)
+	m.mouse = true
+	m = clickAt(t, m, replyChip, 3)
+	if v := stripANSI(m.vp.View()); !strings.Contains(v, "type your reply…") || !strings.Contains(v, "⏎ send") {
+		t.Fatalf("empty reply line should say what to do:\n%s", v)
+	}
+	m = typeText(t, m, "hello")
+	if v := stripANSI(m.vp.View()); strings.Contains(v, "type your reply…") || !strings.Contains(v, "💬 hello▌") || !strings.Contains(v, "esc cancel") {
+		t.Fatalf("typed reply should replace the placeholder and keep the hint:\n%s", v)
+	}
+}
diff --git a/interact.go b/interact.go
index eae8997..2ecb56d 100644
--- a/interact.go
+++ b/interact.go
@@ -286,6 +286,9 @@ func (m model) itemAtLine(line int) (si, ii, start int, ok bool) {
 					end++
 				}
 			}
+			for end-1 > start && strings.TrimSpace(stripANSI(m.renderedLines[end-1])) == "" {
+				end-- // the blank spacer after an item is not part of it
+			}
 			if line >= start && line < end && m.board.Sections[si].Items[ii].Key != emptySectionPlaceholder {
 				return si, ii, start, true
 			}
@@ -376,12 +379,24 @@ func (m model) typingRow(width int) (line int, text string, ok bool) {
 	}
 	for l := start; l < len(m.renderedLines); l++ {
 		if strings.Contains(stripANSI(m.renderedLines[l]), doneChip) {
+			const hint = "⏎ send · esc cancel"
+			showHint := width >= 44
 			room := max(4, width-8)
+			if showHint {
+				room = max(4, width-8-visibleWidth(hint)-2)
+			}
 			shown := m.input
+			if shown == "" {
+				shown = "type your reply…"
+			}
 			for visibleWidth(shown) > room && shown != "" {
 				shown = string([]rune(shown)[1:])
 			}
-			return l, "  " + typingStyle.Render(" 💬 "+shown+"▌ "), true
+			row := "  " + typingStyle.Render(" 💬 "+shown+"▌ ")
+			if showHint {
+				row += "  " + buttonRestStyle.Render(hint)
+			}
+			return l, row, true
 		}
 	}
 	return 0, "", false

From 25afdaf5de2c46d81cf1bc47feb8dc5e97b423cc Mon Sep 17 00:00:00 2001
From: Than Tibbetts <than@broomfitters.com>
Date: Tue, 29 Sep 2026 15:25:33 -0400
Subject: [PATCH 09/11] Make the bullet the control: tick with a click, answer
 the agent's question inline
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Drops the button rows, the emoji, the choice options, and every viewer-side
move between sections — the agent owns the board's motion. A click on a bullet
turns it into ✓ (- [x]) and back; an Ask: line shows as a ? question that opens
a reply under the item; the reply shows as ↳. Whatever is clickable turns solid
under the pointer, and items are spaced one blank line apart.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 README.md                                     |   4 +-
 buttons.go                                    | 300 -----------
 buttons_test.go                               | 475 ------------------
 ...6-09-29-interactive-line-updates-design.md |  43 +-
 edit.go                                       | 170 ++-----
 edit_test.go                                  | 117 ++---
 interact.go                                   | 461 +++++++----------
 interact_test.go                              | 236 +++------
 main.go                                       |  13 +-
 marks.go                                      | 186 +++++++
 marks_test.go                                 | 305 +++++++++++
 sections.go                                   |   2 +-
 semdiff.go                                    |  12 +-
 ui.go                                         |  25 +-
 14 files changed, 879 insertions(+), 1470 deletions(-)
 delete mode 100644 buttons.go
 delete mode 100644 buttons_test.go
 create mode 100644 marks.go
 create mode 100644 marks_test.go

diff --git a/README.md b/README.md
index 1682f69..aad225d 100644
--- a/README.md
+++ b/README.md
@@ -37,8 +37,8 @@ Boards are per-directory. `sidecar init` refuses a board that is a symlink — t
 
 - Renders Markdown with [glamour] and re-renders the moment the file changes. Sidecar watches the parent directory with fsnotify and a 100-millisecond debounce, so it handles atomic rename-swaps, deletes, and recreates — and waits quietly when the file doesn’t exist yet.
 - Scrolls with `j` and `k`, the arrow keys, `PgUp` and `PgDn`, and `g` and `G` for top and bottom, or with the mouse wheel. Sidecar keeps your scroll position across reloads.
-- Talks back to the agent. Under every open item the viewer draws two quiet grey buttons, `[ ✅ Done ]` and `[ 💬 Reply ]`, that turn solid when the pointer is over one. Click Reply, type in your own words right under the item, and press Enter: your reply lands under the item as an `Answer:` line, and `sidecar`'s hook hands it to the agent after its next tool call — no chat message needed. Done moves the item to ✅ Done. `u` — or a click on the status-bar message — undoes the last change made from the viewer, and refuses if the agent has edited the board since. An agent that wants something from you writes an indented `Ask:` line with a narrative question, which shows as `💬 …` above the buttons; `Ask: ✅ Go | ❌ Hold` draws a button per choice instead.
-- Clicks work by default — buttons, checkboxes, items, and section headers. Mouse capture costs the terminal's plain drag-to-select: hold Shift (Option in iTerm2) to select anyway, press `M` to switch capture off and on, or start with `--no-mouse`. Everything also has a key: `]` and `[` select an item, `a` replies, `x` ticks a `- [ ]` item, `d` sends an item to Done, `1`–`9` pick a choice, `}` and `{` jump between open questions, and `esc` deselects.
+- Talks back to the agent. The bullet is the control: click a `•` and it becomes `✓` (the file gets `- [x]`), click again to undo. When the agent asks a question — an indented `Ask:` line, drawn as `? …` — click it, or press `a`, and type your answer under the item; Enter writes it as an `Answer:` line, and `sidecar`'s hook hands it to the agent after its next tool call, no chat message needed. Nothing you do moves an item between sections; that stays the agent's job. `u`, or a click on the status-bar message, undoes the last change and refuses if the agent has edited the board since.
+- Clicks work by default: bullets, questions, section headers, and the wheel. Whatever is clickable turns solid under the pointer. Mouse capture costs the terminal's plain drag-to-select — hold Shift (Option in iTerm2) to select anyway, press `M` to switch capture off and on, or start with `--no-mouse`. Everything also has a key: `]` and `[` select an item, `x` ticks it, `a` replies, `}` and `{` jump between open questions, and `esc` deselects. The status bar counts the questions still waiting on you.
 - `Tab` and `Shift+Tab` move a cursor between sections; `Enter` or `Space` collapses or expands the section under it. `✅ Done` and `📦 Shipped` start collapsed — every heading shows its item count, e.g. `✅ Done (12)`.
 - Reloads on demand with `r`, and quits with `q`.
 - Re-renders when you resize the terminal, at the pane width minus 2. It never renders wider than the pane.
diff --git a/buttons.go b/buttons.go
deleted file mode 100644
index eb384b6..0000000
--- a/buttons.go
+++ /dev/null
@@ -1,300 +0,0 @@
-// buttons.go — the action row under every open item. The board file stays
-// plain text; at display time the viewer draws, beneath each item outside
-// ✅ Done and 📦 Shipped, shaded buttons:
-//
-//	[ ✅ Done ]  [ 💬 Reply ]
-//
-// Reply opens a free-text line (pre-filled with the current reply), Done
-// moves the item to ✅ Done. An "Ask: a | b" line draws its choices as
-// buttons of their own; a narrative "Ask: what did you change?" line shows as
-// the question the reply answers. Clicking any button needs no item selected.
-//
-// The rows are drawn after rendering, not written into the markdown: see
-// addButtonRows.
-package main
-
-import (
-	"regexp"
-	"strings"
-	"unicode"
-
-	"github.com/charmbracelet/lipgloss"
-)
-
-const (
-	doneChip      = "[ ✅ Done ]"
-	replyChip     = "[ 💬 Reply ]"
-	editReplyChip = "[ 💬 Edit reply ]"
-)
-
-var (
-	buttonStyle = lipgloss.NewStyle().Bold(true).
-			Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#7AA2F7"))
-	buttonGoStyle = lipgloss.NewStyle().Bold(true).
-			Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#9ECE6A"))
-	buttonRestStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("#8B93A5"))
-	buttonChosenStyle = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("#9ECE6A"))
-	countIn           = regexp.MustCompile(` \(\d+\)$`)
-)
-
-// finishedLabel reports a ✅ Done or 📦 Shipped heading, with or without the
-// " (N)" item count the display rewrite appends.
-func finishedLabel(label string) bool {
-	label = countIn.ReplaceAllString(label, "")
-	return strings.HasSuffix(label, "Done") || strings.HasSuffix(label, "Shipped")
-}
-
-// actionable is an item that gets an action row: real, and not finished.
-func actionable(label string, it BoardItem) bool {
-	return !finishedLabel(label) && it.Key != emptySectionPlaceholder
-}
-
-// chipText is one choice as drawn: "[ yes ]", or "[ ✓ yes ]" once recorded.
-func chipText(opt string, chosen bool) string {
-	opt = strings.ReplaceAll(opt, "`", "")
-	if chosen {
-		return "[ ✓ " + opt + " ]"
-	}
-	return "[ " + opt + " ]"
-}
-
-// optionChips are the buttons of an "Ask: a | b" line, the recorded one ticked.
-func optionChips(it BoardItem) []string {
-	ans := answerOf(it)
-	var out []string
-	for _, o := range askOptions(it) {
-		out = append(out, chipText(o, ans != "" && strings.EqualFold(ans, o)))
-	}
-	return out
-}
-
-func replyChipFor(it BoardItem) string {
-	if answerOf(it) != "" {
-		return editReplyChip
-	}
-	return replyChip
-}
-
-// rowChips are the buttons under an item, in order.
-func rowChips(it BoardItem) []string { return []string{doneChip, replyChipFor(it)} }
-
-// buttonize redraws each open item's Ask: line: a narrative question shows as
-// "💬 <question>", and a choice line ("Ask: a | b") as "💬 Choose:" — its
-// choices become buttons in the row below the item. The line count never
-// changes; the rows themselves are added after rendering (addButtonRows),
-// because glamour fuses any paragraph added under a list item onto its last
-// line and would wrap a button mid-label.
-func buttonize(raw string, board Board) string {
-	lines := strings.Split(raw, "\n")
-	for _, s := range board.Sections {
-		for _, it := range s.Items {
-			if !actionable(s.Label, it) || !hasAsk(it) {
-				continue
-			}
-			for i := it.StartLine + 1; i <= it.EndLine && i < len(lines); i++ {
-				if !strings.HasPrefix(strings.TrimSpace(lines[i]), "Ask:") {
-					continue
-				}
-				indent := lines[i][:len(lines[i])-len(strings.TrimLeft(lines[i], " \t"))]
-				if q := askText(it); q != "" {
-					lines[i] = indent + "💬 " + q
-				} else {
-					lines[i] = indent + "💬 Choose:"
-				}
-				break
-			}
-		}
-	}
-	return strings.Join(lines, "\n")
-}
-
-// renderBoardLines renders the display markdown and adds every open item's
-// button row. board must be the parse of the file the display text came from,
-// so items line up with the rendered bullets.
-func renderBoardLines(display string, board Board, width int) ([]string, error) {
-	rendered, err := renderMarkdown(display, width, true)
-	if err != nil {
-		return nil, err
-	}
-	lines := strings.Split(rendered, "\n")
-	if len(board.Sections) == 0 {
-		return lines, nil
-	}
-	starts := itemStartLines(lines, sectionHeaderLines(lines), board)
-	return addButtonRows(lines, starts, board, width), nil
-}
-
-// addButtonRows inserts, below the last line of each mapped open item, its
-// buttons — choices first, then Done and Reply — packed to the pane width. An
-// item whose section could not be mapped to rendered lines gets none.
-func addButtonRows(lines []string, starts [][]int, board Board, width int) []string {
-	insert := map[int][]string{}
-	for si, s := range board.Sections {
-		if si >= len(starts) {
-			break
-		}
-		for ii, it := range s.Items {
-			if ii >= len(starts[si]) || !actionable(s.Label, it) {
-				continue
-			}
-			end := starts[si][ii] + 1
-			if ii+1 < len(starts[si]) {
-				end = starts[si][ii+1]
-			} else {
-				for end < len(lines) && strings.TrimSpace(stripANSI(lines[end])) != "" {
-					end++
-				}
-			}
-			// Back up over blank lines so the row hugs the item's last text.
-			for end-1 > starts[si][ii] && strings.TrimSpace(stripANSI(lines[end-1])) == "" {
-				end--
-			}
-			insert[end] = packButtons(append(optionChips(it), rowChips(it)...), width)
-		}
-	}
-	// One blank line between items keeps a long list from reading as a wall:
-	// after each item (and its buttons) whose next line is not already blank.
-	for si, s := range board.Sections {
-		if si >= len(starts) {
-			break
-		}
-		for ii := range s.Items {
-			if ii >= len(starts[si]) {
-				continue
-			}
-			end := starts[si][ii] + 1
-			if ii+1 < len(starts[si]) {
-				end = starts[si][ii+1]
-			} else {
-				for end < len(lines) && strings.TrimSpace(stripANSI(lines[end])) != "" {
-					end++
-				}
-			}
-			for end-1 > starts[si][ii] && strings.TrimSpace(stripANSI(lines[end-1])) == "" {
-				end--
-			}
-			if end < len(lines) && strings.TrimSpace(stripANSI(lines[end])) != "" {
-				insert[end] = append(insert[end], "")
-			}
-		}
-	}
-	var out []string
-	for i, ln := range lines {
-		out = append(out, insert[i]...)
-		out = append(out, ln)
-	}
-	return append(out, insert[len(lines)]...)
-}
-
-// packButtons lays styled buttons into lines no wider than width, two spaces
-// apart and indented two; a button that does not fit starts the next line.
-func packButtons(chips []string, width int) []string {
-	const indent = "  "
-	var rows []string
-	cur, curW := indent, len(indent)
-	for _, c := range chips {
-		w := visibleWidth(c)
-		if curW > len(indent) && curW+2+w > width {
-			rows = append(rows, cur)
-			cur, curW = indent, len(indent)
-		}
-		if curW > len(indent) {
-			cur += "  "
-			curW += 2
-		}
-		cur += styleChip(c)
-		curW += w
-	}
-	return append(rows, cur)
-}
-
-// styleChip paints one button at rest: grey text on no background, so a
-// screen of items is not a screen of color. A recorded choice keeps its green text.
-func styleChip(c string) string {
-	if strings.HasPrefix(c, "[ ✓ ") {
-		return buttonChosenStyle.Render(c)
-	}
-	return buttonRestStyle.Render(c)
-}
-
-// hotChip paints a button under the pointer: solid green for Done, blue for
-// the rest.
-func hotChip(c string) string {
-	if c == doneChip || strings.HasPrefix(c, "[ ✓ ") {
-		return buttonGoStyle.Render(c)
-	}
-	return buttonStyle.Render(c)
-}
-
-// displayText is the board as rendered: collapsed sections dropped and counts
-// added, then every open item's buttons.
-func displayText(raw string, board Board, collapsed map[string]bool) string {
-	collapsedRaw := applyCollapse(raw, board, collapsed)
-	if b, ok := parseBoard(collapsedRaw); ok {
-		return buttonize(collapsedRaw, b)
-	}
-	return collapsedRaw
-}
-
-// normalizeOption reduces an option to its letters and digits, lowercase,
-// so "✅ Done" answers to d and "👍 Yes" to y.
-func normalizeOption(o string) string {
-	return strings.Map(func(r rune) rune {
-		if unicode.IsLetter(r) || unicode.IsDigit(r) {
-			return unicode.ToLower(r)
-		}
-		return -1
-	}, o)
-}
-
-type chipKind int
-
-const (
-	chipOption chipKind = iota
-	chipDone
-	chipReply
-)
-
-// chipAt finds which of the item's buttons covers display column x on a
-// rendered line; ok is false when x is not on a button. For chipOption,
-// option is the choice to record.
-func chipAt(it BoardItem, renderedLine string, x int) (kind chipKind, option string, ok bool) {
-	text := stripANSI(renderedLine)
-	hit := func(c string) bool {
-		idx := strings.Index(text, c)
-		if idx < 0 {
-			return false
-		}
-		col := visibleWidth(text[:idx])
-		return x >= col && x < col+visibleWidth(c)
-	}
-	for i, c := range optionChips(it) {
-		if hit(c) {
-			return chipOption, askOptions(it)[i], true
-		}
-	}
-	switch {
-	case hit(doneChip):
-		return chipDone, "", true
-	case hit(replyChipFor(it)):
-		return chipReply, "", true
-	}
-	return 0, "", false
-}
-
-// chipTextAt is chipAt's twin for hover: the text of the button covering
-// display column x, so it can be found again in the rendered line.
-func chipTextAt(it BoardItem, renderedLine string, x int) (string, bool) {
-	text := stripANSI(renderedLine)
-	for _, c := range append(optionChips(it), rowChips(it)...) {
-		idx := strings.Index(text, c)
-		if idx < 0 {
-			continue
-		}
-		col := visibleWidth(text[:idx])
-		if x >= col && x < col+visibleWidth(c) {
-			return c, true
-		}
-	}
-	return "", false
-}
diff --git a/buttons_test.go b/buttons_test.go
deleted file mode 100644
index f988a70..0000000
--- a/buttons_test.go
+++ /dev/null
@@ -1,475 +0,0 @@
-package main
-
-import (
-	"path/filepath"
-	"strings"
-	"testing"
-
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-	"github.com/muesli/termenv"
-)
-
-const buttonBoard = `# Board
-
-## 🧠 Needs you
-
-- Config rewritten — the deploy script now reads the new keys.
-  Ask: What did you change on your side in the meantime?
-  Next: reply
-
-## ✅ Done
-
-- old
-`
-
-func buttonModel(t *testing.T) (model, string) {
-	t.Helper()
-	p := filepath.Join(t.TempDir(), "sidecar.md")
-	writeFile(t, p, buttonBoard)
-	return testModel(t, p), p
-}
-
-// plainLines renders a board the way the viewer does and strips the color.
-func plainLines(t *testing.T, raw string, collapsed map[string]bool, width int) []string {
-	t.Helper()
-	b, _ := parseBoard(raw)
-	lines, err := renderBoardLines(displayText(raw, b, collapsed), b, width)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i := range lines {
-		lines[i] = strings.TrimRight(stripANSI(lines[i]), " ")
-	}
-	return lines
-}
-
-func TestEveryOpenItemGetsAnActionRowBelowIt(t *testing.T) {
-	raw := "## 🧠 Needs you\n\n- plain\n- has detail\n  more\n\n## ✅ Done\n\n- finished\n"
-	got := plainLines(t, raw, nil, 60)
-	var rows []int
-	for i, l := range got {
-		if strings.Contains(l, doneChip) {
-			rows = append(rows, i)
-		}
-	}
-	if len(rows) != 2 {
-		t.Fatalf("want a row under each of the 2 open items, none under Done:\n%s", strings.Join(got, "\n"))
-	}
-	if !strings.HasPrefix(got[rows[0]-1], "• plain") || !strings.HasPrefix(got[rows[1]-1], "more") {
-		t.Fatalf("rows must hug the last line of their item:\n%s", strings.Join(got, "\n"))
-	}
-	if !strings.Contains(got[rows[0]], "[ 💬 Reply ]") {
-		t.Fatalf("row %q lacks Reply", got[rows[0]])
-	}
-}
-func TestNoRowUnderDoneOrShippedOrPlaceholder(t *testing.T) {
-	raw := "## ✅ Done (1)\n\n- a\n\n## 📦 Shipped\n\n- b\n\n## 🚧 In progress\n\n- " + emptySectionPlaceholder + "\n"
-	b, _ := parseBoard(raw)
-	if got := (buttonize(raw, b)); strings.Contains(got, "Reply") {
-		t.Fatalf("finished and placeholder items get no buttons:\n%s", got)
-	}
-}
-
-func TestNarrativeAskShowsAsTheQuestion(t *testing.T) {
-	b, _ := parseBoard(buttonBoard)
-	got := (buttonize(buttonBoard, b))
-	if !strings.Contains(got, "  💬 What did you change on your side in the meantime?\n") || strings.Contains(got, "Ask:") {
-		t.Fatalf("question not shown:\n%s", got)
-	}
-	if askOptions(b.Sections[0].Items[0]) != nil {
-		t.Fatal("a question without | has no choices")
-	}
-}
-
-func TestChoiceAskStillDrawsChoiceButtons(t *testing.T) {
-	raw := "## 🧠 Needs you\n\n- Merge?\n  Ask: ✅ Go | ❌ Hold\n"
-	got := strings.Join(plainLines(t, raw, nil, 80), "\n")
-	if !strings.Contains(got, "[ ✅ Go ]") || !strings.Contains(got, "[ ❌ Hold ]") || !strings.Contains(got, "💬 Choose:") {
-		t.Fatalf("choices missing:\n%s", got)
-	}
-	raw2 := strings.Replace(raw, "  Ask:", "  Answer: ❌ Hold\n  Ask:", 1)
-	if got := strings.Join(plainLines(t, raw2, nil, 80), "\n"); !strings.Contains(got, "[ ✓ ❌ Hold ]") {
-		t.Fatalf("recorded choice not ticked:\n%s", got)
-	}
-}
-func TestReplyButtonReadsEditOnceReplied(t *testing.T) {
-	raw := "## 🧠 Needs you\n\n- x\n  Answer: did it\n"
-	if got := strings.Join(plainLines(t, raw, nil, 60), "\n"); !strings.Contains(got, "[ 💬 Edit reply ]") {
-		t.Fatalf("got:\n%s", got)
-	}
-}
-func TestCollapsedSectionsKeepTheirCountAndDropTheirButtons(t *testing.T) {
-	m, _ := buttonModel(t)
-	got := strings.Join(plainLines(t, m.raw, map[string]bool{"✅ Done": true}, 60), "\n")
-	if !strings.Contains(got, "✅ Done (1)") || strings.Count(got, doneChip) != 1 {
-		t.Fatalf("got:\n%s", got)
-	}
-}
-func TestButtonsRenderInThePane(t *testing.T) {
-	m, _ := buttonModel(t)
-	view := (stripANSI(m.vp.View()))
-	for _, want := range []string{"[ ✅ Done ]", "[ 💬 Reply ]", "What did you change"} {
-		if !strings.Contains(view, want) {
-			t.Fatalf("pane missing %q:\n%s", want, view)
-		}
-	}
-	if strings.Contains(view, "Ask:") {
-		t.Fatalf("raw Ask: line leaked:\n%s", view)
-	}
-}
-
-func clickAt(t *testing.T, m model, text string, x int) model {
-	t.Helper()
-	for i, ln := range m.renderedLines {
-		if plain := (stripANSI(ln)); strings.Contains(plain, text) {
-			idx := strings.Index(plain, text)
-			msg := tea.MouseMsg{X: visibleWidth(plain[:idx]) + x, Y: i - m.vp.YOffset, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft}
-			next, _ := m.Update(msg)
-			return next.(model)
-		}
-	}
-	t.Fatalf("no rendered line contains %q", text)
-	return m
-}
-
-func TestClickReplyOpensPrefilledLineWithoutSelectingFirst(t *testing.T) {
-	m, p := buttonModel(t)
-	m.mouse = true
-	m = clickAt(t, m, replyChip, 3)
-	if !m.typing || m.input != "" {
-		t.Fatalf("reply button should open an empty answer line, typing=%v input=%q", m.typing, m.input)
-	}
-	m = typeText(t, m, "Restarted the worker by hand")
-	special(t, m, tea.KeyEnter)
-	if got := readFile(t, p); !strings.Contains(got, "  Ask: What did you change on your side in the meantime?\n  Answer: Restarted the worker by hand\n") {
-		t.Fatalf("reply not written under the question:\n%s", got)
-	}
-}
-
-func TestEditReplyPrefillsTheExistingText(t *testing.T) {
-	m, p := buttonModel(t)
-	m.mouse = true
-	m = clickAt(t, m, replyChip, 3)
-	m = typeText(t, m, "first")
-	m = special(t, m, tea.KeyEnter)
-	if !strings.Contains(readFile(t, p), "Answer: first") {
-		t.Fatal("setup: reply not written")
-	}
-	m = clickAt(t, m, editReplyChip, 3)
-	if m.input != "first" {
-		t.Fatalf("edit should prefill, got %q", m.input)
-	}
-	m = typeText(t, m, " and second")
-	special(t, m, tea.KeyEnter)
-	if got := readFile(t, p); strings.Count(got, "Answer:") != 1 || !strings.Contains(got, "Answer: first and second") {
-		t.Fatalf("reply not replaced:\n%s", got)
-	}
-}
-
-func TestUnpromptedReplyLandsLastOnAnItemThatAskedNothing(t *testing.T) {
-	p := filepath.Join(t.TempDir(), "sidecar.md")
-	writeFile(t, p, "## 🧠 Needs you\n\n- Create the API key\n  Next: create it\n")
-	m := testModel(t, p)
-	m.mouse = true
-	m = clickAt(t, m, replyChip, 3)
-	m = typeText(t, m, "made it, pasted in .env")
-	special(t, m, tea.KeyEnter)
-	if got := readFile(t, p); !strings.HasSuffix(got, "  Next: create it\n  Answer: made it, pasted in .env\n") {
-		t.Fatalf("got:\n%s", got)
-	}
-}
-
-func TestClickDoneMovesItAndRecordsWhoDidIt(t *testing.T) {
-	m, p := buttonModel(t)
-	m.mouse = true
-	clickAt(t, m, doneChip, 3)
-	b, _ := parseBoard(readFile(t, p))
-	if len(b.Sections[0].Items) != 0 || len(b.Sections[1].Items) != 2 {
-		t.Fatalf("not moved:\n%s", readFile(t, p))
-	}
-	if answerOf(b.Sections[1].Items[1]) != "✅ Done" {
-		t.Fatalf("Done should leave a reply the hook can read:\n%s", readFile(t, p))
-	}
-}
-
-func TestDoneKeepsAnExistingReply(t *testing.T) {
-	m, p := buttonModel(t)
-	m.mouse = true
-	m = clickAt(t, m, replyChip, 3)
-	m = typeText(t, m, "did it differently")
-	m = special(t, m, tea.KeyEnter)
-	clickAt(t, m, doneChip, 3)
-	if got := readFile(t, p); !strings.Contains(got, "Answer: did it differently") || strings.Contains(got, "Answer: ✅ Done") {
-		t.Fatalf("Done must not overwrite a narrative reply:\n%s", got)
-	}
-}
-
-func TestOptionButtonClickRecordsTheChoice(t *testing.T) {
-	p := filepath.Join(t.TempDir(), "sidecar.md")
-	writeFile(t, p, "## 🧠 Needs you\n\n- Merge?\n  Ask: Go | Hold\n")
-	m := testModel(t, p)
-	m.mouse = true
-	clickAt(t, m, "[ Hold ]", 2)
-	if got := readFile(t, p); !strings.Contains(got, "  Answer: Hold\n") {
-		t.Fatalf("got:\n%s", got)
-	}
-}
-
-func TestClickBetweenButtonsOnlySelects(t *testing.T) {
-	m, p := buttonModel(t)
-	m.mouse = true
-	m = clickAt(t, m, "Next: reply", 0)
-	if m.itemSec < 0 || readFile(t, p) != buttonBoard {
-		t.Fatal("a click off the buttons should select, not write")
-	}
-}
-
-func TestClickIgnoredWhenMouseIsOff(t *testing.T) {
-	m, p := buttonModel(t)
-	clickAt(t, m, doneChip, 3)
-	if readFile(t, p) != buttonBoard {
-		t.Fatal("buttons must not respond while mouse is off")
-	}
-}
-
-func TestEmojiChoiceAnswersToLetterKeys(t *testing.T) {
-	p := filepath.Join(t.TempDir(), "sidecar.md")
-	writeFile(t, p, "## 🧠 Needs you\n\n- Merge?\n  Ask: ✅ Done | ❌ No\n")
-	m := testModel(t, p)
-	m = press(t, m, "]", "n")
-	if !strings.Contains(readFile(t, p), "Answer: ❌ No") {
-		t.Fatalf("n should pick ❌ No:\n%s", readFile(t, p))
-	}
-}
-
-func TestAKeyRepliesOnAnyItem(t *testing.T) {
-	m, p := buttonModel(t)
-	m = press(t, m, "]", "a")
-	if !m.typing {
-		t.Fatal("a should open the reply line on any item")
-	}
-	m = typeText(t, m, "ok")
-	special(t, m, tea.KeyEnter)
-	if !strings.Contains(readFile(t, p), "Answer: ok") {
-		t.Fatalf("got:\n%s", readFile(t, p))
-	}
-}
-
-const wideBoard = `# Board
-
-## 🧠 Needs you
-
-- PR #30 lets the human answer the agent from the board, with a long line that wraps at every pane width the test tries. It ends mid sentence so the button row cannot hide in slack space.
-  https://github.com/than/sidecar/pull/30
-  Ask: What did you change on your side while this ran, and did the deploy behave?
-  Next: review and merge.
-
-## 🚧 In progress
-
-- Short one.
-- Second short one with **bold** and a [link](https://example.com/a/long/path/that/keeps/going).
-
-## ✅ Done
-
-- shipped
-`
-
-// A button that wraps mid-label cannot be clicked, so at every pane width
-// each open item's buttons must sit whole on one rendered line, and a click
-// on them must act.
-func TestButtonsStayWholeAndClickableAtEveryWidth(t *testing.T) {
-	for w := 24; w <= 200; w += 7 {
-		p := filepath.Join(t.TempDir(), "sidecar.md")
-		writeFile(t, p, wideBoard)
-		m := newModel(p, false)
-		m.mouse = true
-		next, _ := m.Update(tea.WindowSizeMsg{Width: w, Height: 60})
-		m = next.(model)
-		rows := 0
-		for _, ln := range m.renderedLines {
-			plain := (stripANSI(ln))
-			if strings.Contains(plain, doneChip) {
-				rows++
-				if !strings.Contains(plain, replyChip) && w >= 30 {
-					t.Fatalf("width %d: Done and Reply split across lines: %q", w, plain)
-				}
-			}
-		}
-		if rows != 3 {
-			t.Fatalf("width %d: want 3 whole button rows, got %d\n%s", w, rows, stripANSI(strings.Join(m.renderedLines, "\n")))
-		}
-		m2 := clickAt(t, m, replyChip, 3)
-		if !m2.typing {
-			t.Fatalf("width %d: clicking Reply did nothing", w)
-		}
-		m3 := clickAt(t, m, doneChip, 3)
-		if m3.notice == "" && readFile(t, p) == wideBoard {
-			t.Fatalf("width %d: clicking Done did nothing", w)
-		}
-	}
-}
-
-func motionAt(t *testing.T, m model, text string, x int) model {
-	t.Helper()
-	for i, ln := range m.renderedLines {
-		if plain := stripANSI(ln); strings.Contains(plain, text) {
-			idx := strings.Index(plain, text)
-			next, _ := m.Update(tea.MouseMsg{X: visibleWidth(plain[:idx]) + x, Y: i - m.vp.YOffset, Action: tea.MouseActionMotion})
-			return next.(model)
-		}
-	}
-	t.Fatalf("no rendered line contains %q", text)
-	return m
-}
-
-func TestButtonsRestQuietAndPaintUnderThePointer(t *testing.T) {
-	prev := lipgloss.ColorProfile()
-	lipgloss.SetColorProfile(termenv.TrueColor)
-	t.Cleanup(func() { lipgloss.SetColorProfile(prev) })
-	m, _ := buttonModel(t)
-	m.mouse = true
-	rest := m.vp.View()
-	m = motionAt(t, m, replyChip, 3)
-	if m.hover.line < 0 || m.hover.chip != replyChip {
-		t.Fatalf("hover not tracked: %+v", m.hover)
-	}
-	if hot := m.vp.View(); hot == rest || !strings.Contains(hot, buttonStyle.Render(replyChip)) {
-		t.Fatal("the hovered button should repaint solid blue")
-	}
-	if strings.Contains(rest, buttonStyle.Render(replyChip)) || strings.Contains(rest, buttonGoStyle.Render(doneChip)) {
-		t.Fatal("buttons at rest must not be painted solid")
-	}
-	m = motionAt(t, m, "Next:", 0) // pointer leaves the buttons
-	if m.hover.line != -1 || m.vp.View() != rest {
-		t.Fatal("moving off a button should return it to rest")
-	}
-}
-
-func TestHoverIgnoredWithMouseOff(t *testing.T) {
-	m, _ := buttonModel(t)
-	m = motionAt(t, m, replyChip, 3)
-	if m.hover.line != -1 {
-		t.Fatal("no hover while mouse is off")
-	}
-}
-
-func TestUndoRestoresTheBoardAndRefusesAfterAgentEdits(t *testing.T) {
-	m, p := buttonModel(t)
-	m.mouse = true
-	m = clickAt(t, m, doneChip, 3)
-	if !strings.Contains(m.notice, "u to undo") {
-		t.Fatalf("notice %q should offer undo", m.notice)
-	}
-	m = press(t, m, "u")
-	if readFile(t, p) != buttonBoard || m.notice != "undone" {
-		t.Fatalf("undo did not restore the board (notice %q):\n%s", m.notice, readFile(t, p))
-	}
-	// Move again, then let the agent edit: undo must not clobber it.
-	m = clickAt(t, m, doneChip, 3)
-	writeFile(t, p, readFile(t, p)+"- agent added this\n")
-	m = press(t, m, "u")
-	if !strings.Contains(readFile(t, p), "- agent added this") || !strings.Contains(m.notice, "changed since") {
-		t.Fatalf("undo overwrote the agent's edit (notice %q)", m.notice)
-	}
-}
-
-func TestClickingTheStatusMessageUndoes(t *testing.T) {
-	m, p := buttonModel(t)
-	m.mouse = true
-	m = clickAt(t, m, doneChip, 3)
-	next, _ := m.Update(tea.MouseMsg{X: 5, Y: m.vp.Height, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft})
-	_ = next
-	if readFile(t, p) != buttonBoard {
-		t.Fatal("clicking the status bar should undo the last change")
-	}
-}
-
-func TestUKeyScrollsWhenNothingToUndo(t *testing.T) {
-	m, _ := buttonModel(t)
-	m = press(t, m, "u")
-	if m.notice != "" {
-		t.Fatalf("u with nothing to undo should fall through to the viewport, got %q", m.notice)
-	}
-}
-
-func TestReplyIsTypedInlineUnderTheItem(t *testing.T) {
-	m, _ := buttonModel(t)
-	m.mouse = true
-	m = clickAt(t, m, replyChip, 3)
-	m = typeText(t, m, "worker restarted")
-	view := stripANSI(m.vp.View())
-	if !strings.Contains(view, "💬 worker restarted▌") {
-		t.Fatalf("typed text should appear under the item:\n%s", view)
-	}
-	if strings.Contains(view, replyChip) {
-		t.Fatal("the typed line replaces the button row while typing")
-	}
-	m = special(t, m, tea.KeyEsc)
-	if v := stripANSI(m.vp.View()); !strings.Contains(v, replyChip) || strings.Contains(v, "worker restarted") {
-		t.Fatalf("esc should bring the buttons back:\n%s", v)
-	}
-}
-
-func TestOneBlankLineSeparatesItems(t *testing.T) {
-	raw := "## 🧠 Needs you\n\n- first\n- second\n  more\n- third\n\n## ✅ Done\n\n- a\n- b\n"
-	got := plainLines(t, raw, nil, 60)
-	text := strings.Join(got, "\n")
-	for _, pair := range [][2]string{{"• first", "• second"}, {"more", "• third"}} {
-		a, b := strings.Index(text, pair[0]), strings.Index(text, pair[1])
-		between := text[a:b]
-		if !strings.Contains(between, "\n\n") || strings.Contains(between, "\n\n\n") {
-			t.Fatalf("want exactly one blank line between %q and %q, got %q\n%s", pair[0], pair[1], between, text)
-		}
-	}
-	if strings.Contains(text, "\n\n\n") {
-		t.Fatalf("no run of blank lines anywhere:\n%s", text)
-	}
-	// Finished items are spaced too.
-	if a, b := strings.Index(text, "• a"), strings.Index(text, "• b"); !strings.Contains(text[a:b], "\n\n") {
-		t.Fatalf("Done items should be spaced:\n%s", text)
-	}
-}
-
-func TestSpacerDoesNotBreakClickingOrSelection(t *testing.T) {
-	p := filepath.Join(t.TempDir(), "sidecar.md")
-	writeFile(t, p, "## 🧠 Needs you\n\n- first\n- second\n\n## ✅ Done\n\n- old\n")
-	m := testModel(t, p)
-	m.mouse = true
-	m = clickAt(t, m, doneChip, 3) // first row's Done
-	b, _ := parseBoard(readFile(t, p))
-	if len(b.Sections[0].Items) != 1 || b.Sections[0].Items[0].Key != "second" {
-		t.Fatalf("clicked the wrong item's Done:\n%s", readFile(t, p))
-	}
-	m = press(t, m, "]", "]") // items still map one-to-one with spacers present
-	if it, _, ok := m.selected(); !ok || it.Key != "second" {
-		t.Fatalf("selection lost with spacers in the layout")
-	}
-}
-
-func TestButtonsHaveNoBackgroundAtRest(t *testing.T) {
-	prev := lipgloss.ColorProfile()
-	lipgloss.SetColorProfile(termenv.TrueColor)
-	t.Cleanup(func() { lipgloss.SetColorProfile(prev) })
-	for _, c := range []string{doneChip, replyChip, chipText("Go", true), chipText("Go", false)} {
-		if strings.Contains(styleChip(c), "48;") {
-			t.Fatalf("%q paints a background at rest: %q", c, styleChip(c))
-		}
-	}
-	if !strings.Contains(hotChip(replyChip), "48;") || !strings.Contains(hotChip(doneChip), "48;") {
-		t.Fatal("hovered buttons should paint a background")
-	}
-}
-
-func TestTypingRowHintsHowToSend(t *testing.T) {
-	m, _ := buttonModel(t)
-	m.mouse = true
-	m = clickAt(t, m, replyChip, 3)
-	if v := stripANSI(m.vp.View()); !strings.Contains(v, "type your reply…") || !strings.Contains(v, "⏎ send") {
-		t.Fatalf("empty reply line should say what to do:\n%s", v)
-	}
-	m = typeText(t, m, "hello")
-	if v := stripANSI(m.vp.View()); strings.Contains(v, "type your reply…") || !strings.Contains(v, "💬 hello▌") || !strings.Contains(v, "esc cancel") {
-		t.Fatalf("typed reply should replace the placeholder and keep the hint:\n%s", v)
-	}
-}
diff --git a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
index 2b8d807..08f1a24 100644
--- a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
+++ b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
@@ -1,54 +1,49 @@
 # Interactive line updates
 
-The viewer gains one write path so the human can answer the agent from the board, and the hook cycle hands the answer to the agent mid-turn.
+The viewer is the human's channel back to the agent. The agent owns the board and every move on it; the human only says "I did this" and answers questions, and the hook cycle hands both to the agent mid-turn.
 
 ## Intent
 
 - An agent leaves the result of a turn as an entry. The human, who may be in another tab, says what they did in between, in their own words.
 - The agent asks a narrative question, not a yes/no.
 - Always clickable: mouse capture is on by default (`--no-mouse` and `M` release it). Shift-drag (Option in iTerm2) still selects text.
+- No emoji, no buttons. The characters already on the board are the controls.
 
-## What the human sees
+## What the human sees and does
 
-Under every open item — everything outside ✅ Done and 📦 Shipped — two buttons:
-
-    [ ✅ Done ]  [ 💬 Reply ]
-
-- Buttons rest as quiet grey blocks and turn solid (green Done, blue the rest) under the pointer, so a screen of items stays calm. They are drawn after rendering, on their own line below each item.
-- **Reply** opens a free-text line under the item, where the button row was, pre-filled with the current reply. Enter writes `Answer: <text>` under the item, replacing an earlier one; esc abandons it. While typing, every key is text.
-- **Done** moves the item to ✅ Done. When the human has said nothing else it also writes `Answer: ✅ Done`, so the hook can tell a human finished it.
-- An `Ask:` line with no `|` is the question. It shows as `💬 <question>` above the buttons. An `Ask: a | b` line is a choice and draws one button per option; the recorded choice is ticked.
+- **The bullet is the control.** Click `•` and it turns into `✓`; the file gets `- [x]`. Click again and it is a plain bullet. `x` does the same on the selected item.
+- **`? question`** — an `Ask:` line is drawn as `? …` in the accent color. Click it, or press `a` on the item, and a reply line opens under the item; Enter writes it, esc abandons it. The reply shows as `↳ …`. The reply line is pre-filled with the current reply so it can be edited, and shows `type your reply… ⏎ send · esc cancel` when empty.
+- Whatever is clickable — bullet or question — turns solid under the pointer; nothing else changes on hover.
+- One blank line separates items.
+- The viewer never moves an item between sections. Filing stays with the agent.
 
 ## Board syntax
 
-Plain markdown; the file never contains a button.
+Plain markdown; the file never contains a control.
 
 - `  Ask: what did you change?` — the agent's question.
-- `  Ask: ✅ Go | ❌ Hold` — optional choices.
-- `  Answer: …` — the human's reply. It is written under `Ask:` when there is one and last otherwise, so a reply works on an item that asked nothing.
-- `- [ ]` / `- [x]` — a checklist item; the box ticks on a click in the first two columns or `x`.
+- `  Answer: …` — the human's reply. It is written under `Ask:` when there is one and last otherwise, so an unprompted reply works on any item.
+- `- [x] …` — ticked. `[ ]` and plain bullets both tick to `[x]`; unticking returns to a plain bullet.
 
 ## Delivery
 
 - `sidecar diff` (UserPromptSubmit) is unchanged and reports everything since the last prompt.
 - `sidecar diff --mid-turn` (PostToolUse) prints hook JSON only when the human replied or ticked, and stays silent for anything else, including the agent's own edits. It advances the snapshot only when it reported, so a reply arrives once.
 - `sidecar init` installs both hooks; the mid-turn one carries the same sentinel, so a re-run replaces it.
-- The diff line reads `edited 🧠: "Title" — replied "…"`; a tick reads `— ticked`.
-
-## Writes
-
-`editItem` re-reads the file, finds the item by section label and exact text, applies a pure text transform, and swaps the file in by rename, keeping its mode. An agent edit elsewhere survives; if the item itself changed since it was rendered, nothing is written and the status bar says so.
+- The diff line reads `edited 🧠: "Title" — replied "…"`; a tick reads `— ticked`, an untick `— unticked`.
 
-## Undo
+## Writes and undo
 
-Every write made from the viewer is remembered with the file as it stood before and after. `u`, or a click on the status message, restores the earlier file — but only while the file still reads exactly as that write left it, so undo can never overwrite what the agent wrote since. Every click also says what it did in the status bar, so none looks ignored.
+- `editItem` re-reads the file, finds the item by section label and exact text, applies a pure text transform, and swaps the file in by rename, keeping its mode. An agent edit elsewhere survives; if the item itself changed since it was rendered, nothing is written and the status bar says so.
+- Every write is remembered with the file before and after. `u`, or a click on the status message, restores the earlier file — but only while the file still reads exactly as that write left it, so undo never overwrites the agent.
+- Every click reports its outcome in the status bar, so none looks ignored.
 
 ## Keyboard
 
-`]` / `[` select an item, `a` replies, `d` sends it to Done, `x` ticks, `1`–`9` and `y` / `n` / `d` pick a choice, `}` / `{` jump between unanswered questions, `esc` deselects. The status bar counts open questions.
+`]` / `[` select an item, `x` ticks, `a` replies, `}` / `{` jump between unanswered questions, `u` undoes, `esc` deselects. The status bar counts open questions.
 
 ## Known limits
 
-- Rows are found by their column-0 marker; a section whose rendered count differs from the parsed count (collapsed) is skipped rather than mis-selected.
+- Items are mapped to rendered lines by their column-0 marker (`•`, `□`, `✓`); a section whose rendered count differs from the parsed count (collapsed) is skipped rather than mis-selected.
 - When `--mid-turn` reports, the snapshot advances whole, so an agent edit made in the same window is not repeated in the next prompt's diff.
-- Clicking a link: capture may stop the terminal's own link handling; the viewer does not open links itself yet.
+- Clicking a link while capture is on may not reach the terminal's own link handling; the viewer does not open links itself yet.
diff --git a/edit.go b/edit.go
index 688d599..27ba929 100644
--- a/edit.go
+++ b/edit.go
@@ -1,13 +1,13 @@
-// edit.go — the viewer's only writes to the board: tick a checklist item,
-// answer an Ask: prompt, or move an item to ✅ Done. Every edit is a pure
-// text transform on one item, located by section label and exact item text
-// in the file as it is on disk right now, so an unrelated edit by the agent
-// between render and keypress is preserved and a conflicting one is refused.
+// edit.go — the viewer's only writes to the board, each a pure text transform
+// on one item: tick it (• ↔ ✓) or set its reply. The viewer never moves an
+// item between sections; that is the agent's job. Every edit locates the item
+// by section label and exact text in the file as it is on disk right now, so
+// an unrelated edit by the agent between render and click is preserved and a
+// conflicting one is refused.
 package main
 
 import (
 	"errors"
-	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -15,60 +15,42 @@ import (
 
 var errBoardChanged = errors.New("board changed under the cursor — nothing written")
 
-// checkboxPrefixes are the task-list markers on an item's first line.
 const (
 	unticked = "- [ ] "
 	ticked   = "- [x] "
 )
 
-// isCheckbox reports whether an item's first line is a task-list item.
-func isCheckbox(it BoardItem) bool {
-	first := firstLine(it.Raw)
-	return strings.HasPrefix(first, unticked) || strings.HasPrefix(strings.ToLower(first), ticked)
-}
-
 func firstLine(raw string) string {
 	first, _, _ := strings.Cut(raw, "\n")
 	return first
 }
 
-// toggleCheckbox flips "- [ ]" and "- [x]" on the item's first line.
-func toggleCheckbox(lines []string) ([]string, error) {
+// isTicked reports an item whose first line is "- [x] …" — drawn ✓.
+func isTicked(it BoardItem) bool {
+	return strings.HasPrefix(strings.ToLower(firstLine(it.Raw)), ticked)
+}
+
+// toggleTick turns a plain or "- [ ]" item into "- [x]", and a ticked one back
+// into a plain bullet. Ticking is the human saying "I did this"; unticking
+// takes it back.
+func toggleTick(lines []string) ([]string, error) {
 	out := append([]string(nil), lines...)
+	first := out[0]
 	switch {
-	case strings.HasPrefix(out[0], unticked):
-		out[0] = ticked + strings.TrimPrefix(out[0], unticked)
-	case strings.HasPrefix(strings.ToLower(out[0]), ticked):
-		out[0] = unticked + out[0][len(ticked):]
+	case strings.HasPrefix(strings.ToLower(first), ticked):
+		out[0] = "- " + first[len(ticked):]
+	case strings.HasPrefix(first, unticked):
+		out[0] = ticked + strings.TrimPrefix(first, unticked)
+	case strings.HasPrefix(first, "- "):
+		out[0] = ticked + strings.TrimPrefix(first, "- ")
 	default:
-		return nil, errors.New("not a checklist item")
+		return nil, errors.New("not a list item")
 	}
 	return out, nil
 }
 
-// askOptions returns the options of an item's "Ask:" line — "Ask: yes | no"
-// yields ["yes", "no"] — or nil when the item asks nothing.
-func askOptions(it BoardItem) []string {
-	_, rest, _ := strings.Cut(it.Raw, "\n")
-	for _, ln := range strings.Split(rest, "\n") {
-		if v, ok := strings.CutPrefix(strings.TrimSpace(ln), "Ask:"); ok {
-			if !strings.Contains(v, "|") {
-				return nil // a narrative question, not a choice
-			}
-			var opts []string
-			for _, o := range strings.Split(v, "|") {
-				if o = strings.TrimSpace(o); o != "" {
-					opts = append(opts, o)
-				}
-			}
-			return opts
-		}
-	}
-	return nil
-}
-
-// hasAsk reports whether the item carries an "Ask:" line at all — options or
-// not. An Ask: with no options is an open question, answered in free text.
+// hasAsk reports whether the item carries an "Ask:" line — the agent's
+// question, which the human answers in their own words.
 func hasAsk(it BoardItem) bool {
 	_, rest, _ := strings.Cut(it.Raw, "\n")
 	for _, ln := range strings.Split(rest, "\n") {
@@ -94,18 +76,6 @@ func cleanAnswer(s string) string {
 	return strings.Join(strings.Fields(s), " ")
 }
 
-// askText is the question on an item's "Ask:" line when it is narrative —
-// no "|" choices — and "" otherwise.
-func askText(it BoardItem) string {
-	_, rest, _ := strings.Cut(it.Raw, "\n")
-	for _, ln := range strings.Split(rest, "\n") {
-		if v, ok := strings.CutPrefix(strings.TrimSpace(ln), "Ask:"); ok && !strings.Contains(v, "|") {
-			return strings.TrimSpace(v)
-		}
-	}
-	return ""
-}
-
 // answerOf returns the item's current "Answer:" value, "" when unanswered.
 func answerOf(it BoardItem) string {
 	_, rest, _ := strings.Cut(it.Raw, "\n")
@@ -117,10 +87,10 @@ func answerOf(it BoardItem) string {
 	return ""
 }
 
-// setAnswer writes "Answer: <option>" directly under the Ask: line — or last,
+// setAnswer writes "Answer: <text>" directly under the Ask: line — or last,
 // when the item asked nothing — replacing an earlier answer so the item never
 // carries two.
-func setAnswer(lines []string, option string) ([]string, error) {
+func setAnswer(lines []string, text string) ([]string, error) {
 	askAt := -1
 	for i, ln := range lines[1:] {
 		if strings.HasPrefix(strings.TrimSpace(ln), "Ask:") {
@@ -128,19 +98,6 @@ func setAnswer(lines []string, option string) ([]string, error) {
 			break
 		}
 	}
-	if askAt < 0 {
-		// An unprompted reply: the human volunteers something about an item
-		// the agent never asked about. It goes last, replacing an earlier one.
-		var out []string
-		for i, ln := range lines {
-			if i > 0 && strings.HasPrefix(strings.TrimSpace(ln), "Answer:") {
-				continue
-			}
-			out = append(out, ln)
-		}
-		return append(out, "  Answer: "+option), nil
-	}
-	indent := lines[askAt][:len(lines[askAt])-len(strings.TrimLeft(lines[askAt], " \t"))]
 	var out []string
 	for i, ln := range lines {
 		if i > 0 && strings.HasPrefix(strings.TrimSpace(ln), "Answer:") {
@@ -148,74 +105,14 @@ func setAnswer(lines []string, option string) ([]string, error) {
 		}
 		out = append(out, ln)
 		if i == askAt {
-			out = append(out, indent+"Answer: "+option)
-		}
-	}
-	return out, nil
-}
-
-// moveItem returns raw with the item at (si, ii) moved to the end of the
-// section labeled target, replacing that section's "nothing yet" placeholder.
-func moveItem(raw string, b Board, si, ii int, target string) (string, error) {
-	ti := -1
-	for i, s := range b.Sections {
-		if s.Label == target {
-			ti = i
-		}
-	}
-	if ti < 0 {
-		return "", fmt.Errorf("no %q section", target)
-	}
-	if ti == si {
-		return "", errors.New("already there")
-	}
-	lines := strings.Split(raw, "\n")
-	it := b.Sections[si].Items[ii]
-	block := append([]string(nil), lines[it.StartLine:it.EndLine+1]...)
-
-	ts := b.Sections[ti]
-	skip := make([]bool, len(lines))
-	for i := it.StartLine; i <= it.EndLine; i++ {
-		skip[i] = true
-	}
-	at := ts.HeaderLine + 1 // insert before this original index
-	blankFirst := false
-	real := 0
-	for _, x := range ts.Items {
-		if x.Key == emptySectionPlaceholder {
-			for i := x.StartLine; i <= x.EndLine; i++ {
-				skip[i] = true
-			}
-			at = x.StartLine
-			continue
-		}
-		real++
-		at = x.EndLine + 1
-	}
-	if real == 0 && len(ts.Items) == 0 {
-		if at < len(lines) && strings.TrimSpace(lines[at]) == "" {
-			at++
-		} else {
-			blankFirst = true
+			indent := ln[:len(ln)-len(strings.TrimLeft(ln, " \t"))]
+			out = append(out, indent+"Answer: "+text)
 		}
 	}
-
-	var out []string
-	for i := 0; i <= len(lines); i++ {
-		if i == at {
-			if blankFirst {
-				out = append(out, "")
-			}
-			out = append(out, block...)
-			if blankFirst {
-				out = append(out, "")
-			}
-		}
-		if i < len(lines) && !skip[i] {
-			out = append(out, lines[i])
-		}
+	if askAt < 0 {
+		out = append(out, "  Answer: "+text)
 	}
-	return strings.Join(out, "\n"), nil
+	return out, nil
 }
 
 // editItem re-reads the board, finds the item by section label and exact
@@ -248,8 +145,7 @@ func editItem(path, label, oldRaw string, fn func(raw string, b Board, si, ii in
 	return errBoardChanged
 }
 
-// replaceLines is the common shape of tick and answer: swap one item's
-// lines for the transform of them.
+// replaceLines swaps one item's lines for the transform of them.
 func replaceLines(t func([]string) ([]string, error)) func(string, Board, int, int) (string, error) {
 	return func(raw string, b Board, si, ii int) (string, error) {
 		it := b.Sections[si].Items[ii]
diff --git a/edit_test.go b/edit_test.go
index c9ea9ce..acf67e6 100644
--- a/edit_test.go
+++ b/edit_test.go
@@ -11,9 +11,9 @@ const editBoard = `# Board
 
 ## 🧠 Needs you
 
-- [ ] Ship it
-- Pick a path
-  Ask: yes | no | done
+- Ship it
+- Which name?
+  Ask: What should we call it?
   Next: answer
 
 ## 🚧 In progress
@@ -43,49 +43,54 @@ func readFile(t *testing.T, p string) string {
 	return string(d)
 }
 
-func TestToggleCheckboxBothWays(t *testing.T) {
-	on, err := toggleCheckbox([]string{"- [ ] a", "  more"})
-	if err != nil || on[0] != "- [x] a" || on[1] != "  more" {
+func TestToggleTickBothWays(t *testing.T) {
+	on, err := toggleTick([]string{"- plain", "  more"})
+	if err != nil || on[0] != "- [x] plain" || on[1] != "  more" {
 		t.Fatalf("tick: %v %v", on, err)
 	}
-	off, _ := toggleCheckbox([]string{"- [X] a"})
-	if off[0] != "- [ ] a" {
-		t.Fatalf("untick: %v", off)
+	off, _ := toggleTick([]string{"- [X] plain"})
+	if off[0] != "- plain" {
+		t.Fatalf("untick returns to a plain bullet: %v", off)
 	}
-	if _, err := toggleCheckbox([]string{"- plain"}); err == nil {
-		t.Fatal("plain bullet must not toggle")
+	box, _ := toggleTick([]string{"- [ ] task"})
+	if box[0] != "- [x] task" {
+		t.Fatalf("an unchecked box ticks: %v", box)
+	}
+	if _, err := toggleTick([]string{"1. numbered"}); err == nil {
+		t.Fatal("only dash bullets tick")
 	}
 }
 
-func TestAskOptionsAndAnswer(t *testing.T) {
+func TestSetAnswerGoesUnderAskAndReplaces(t *testing.T) {
 	b, _ := parseBoard(editBoard)
-	it := b.Sections[0].Items[1]
-	if got := strings.Join(askOptions(it), ","); got != "yes,no,done" {
-		t.Fatalf("options %q", got)
-	}
-	lines := strings.Split(it.Raw, "\n")
-	a, err := setAnswer(lines, "no")
+	lines := strings.Split(b.Sections[0].Items[1].Raw, "\n")
+	a, err := setAnswer(lines, "Sidecar")
 	if err != nil {
 		t.Fatal(err)
 	}
-	if a[2] != "  Answer: no" || len(a) != 4 {
-		t.Fatalf("answer placement: %q", a)
+	if a[2] != "  Answer: Sidecar" || len(a) != 4 || a[3] != "  Next: answer" {
+		t.Fatalf("placement: %q", a)
 	}
-	a2, _ := setAnswer(a, "yes")
-	if len(a2) != 4 || a2[2] != "  Answer: yes" {
-		t.Fatalf("re-answer must replace: %q", a2)
+	a2, _ := setAnswer(a, "Wingman")
+	if len(a2) != 4 || a2[2] != "  Answer: Wingman" {
+		t.Fatalf("a new reply must replace the old one: %q", a2)
+	}
+}
+
+func TestSetAnswerOnAnItemThatAskedNothingGoesLast(t *testing.T) {
+	a, _ := setAnswer([]string{"- Create the key", "  Next: create it"}, "made it")
+	if strings.Join(a, "|") != "- Create the key|  Next: create it|  Answer: made it" {
+		t.Fatalf("%q", a)
 	}
 }
 
 func TestEditItemWritesOnlyThatItem(t *testing.T) {
 	p := writeBoardFile(t, editBoard)
 	b, _ := parseBoard(editBoard)
-	it := b.Sections[0].Items[0]
-	if err := editItem(p, "🧠 Needs you", it.Raw, replaceLines(toggleCheckbox)); err != nil {
+	if err := editItem(p, "🧠 Needs you", b.Sections[0].Items[0].Raw, replaceLines(toggleTick)); err != nil {
 		t.Fatal(err)
 	}
-	want := strings.Replace(editBoard, "- [ ] Ship it", "- [x] Ship it", 1)
-	if got := readFile(t, p); got != want {
+	if got, want := readFile(t, p), strings.Replace(editBoard, "- Ship it", "- [x] Ship it", 1); got != want {
 		t.Fatalf("got:\n%s\nwant:\n%s", got, want)
 	}
 }
@@ -93,8 +98,7 @@ func TestEditItemWritesOnlyThatItem(t *testing.T) {
 func TestEditItemRefusesWhenItemChanged(t *testing.T) {
 	p := writeBoardFile(t, strings.Replace(editBoard, "Ship it", "Ship it now", 1))
 	b, _ := parseBoard(editBoard)
-	err := editItem(p, "🧠 Needs you", b.Sections[0].Items[0].Raw, replaceLines(toggleCheckbox))
-	if err != errBoardChanged {
+	if err := editItem(p, "🧠 Needs you", b.Sections[0].Items[0].Raw, replaceLines(toggleTick)); err != errBoardChanged {
 		t.Fatalf("want errBoardChanged, got %v", err)
 	}
 }
@@ -102,7 +106,7 @@ func TestEditItemRefusesWhenItemChanged(t *testing.T) {
 func TestEditItemKeepsConcurrentEditsElsewhere(t *testing.T) {
 	p := writeBoardFile(t, editBoard+"- added by agent\n")
 	b, _ := parseBoard(editBoard)
-	if err := editItem(p, "🧠 Needs you", b.Sections[0].Items[0].Raw, replaceLines(toggleCheckbox)); err != nil {
+	if err := editItem(p, "🧠 Needs you", b.Sections[0].Items[0].Raw, replaceLines(toggleTick)); err != nil {
 		t.Fatal(err)
 	}
 	if got := readFile(t, p); !strings.Contains(got, "- added by agent") || !strings.Contains(got, "- [x] Ship it") {
@@ -110,56 +114,19 @@ func TestEditItemKeepsConcurrentEditsElsewhere(t *testing.T) {
 	}
 }
 
-func TestMoveItemIntoPlaceholderSection(t *testing.T) {
-	b, _ := parseBoard(editBoard)
-	got, err := moveItem(editBoard, b, 0, 1, "🚧 In progress")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(got, emptySectionPlaceholder) {
-		t.Fatalf("placeholder survived:\n%s", got)
-	}
-	b2, _ := parseBoard(got)
-	if len(b2.Sections[0].Items) != 1 || !strings.HasPrefix(b2.Sections[1].Items[0].Raw, "- Pick a path\n  Ask:") {
-		t.Fatalf("bad move:\n%s", got)
-	}
-}
-
-func TestMoveItemAppendsAfterLastItem(t *testing.T) {
-	b, _ := parseBoard(editBoard)
-	got, err := moveItem(editBoard, b, 0, 0, "✅ Done")
-	if err != nil {
-		t.Fatal(err)
-	}
-	b2, _ := parseBoard(got)
-	done := b2.Sections[2].Items
-	if len(done) != 2 || done[0].Key != "old" || done[1].Key != "Ship it" {
-		t.Fatalf("bad move:\n%s", got)
-	}
-}
-
-func TestMoveItemIntoTrulyEmptySection(t *testing.T) {
-	raw := "## A\n\n- x\n\n## B\n\n## C\n\n- z\n"
-	b, _ := parseBoard(raw)
-	got, err := moveItem(raw, b, 0, 0, "B")
-	if err != nil {
-		t.Fatal(err)
-	}
-	b2, _ := parseBoard(got)
-	if len(b2.Sections[1].Items) != 1 || b2.Sections[1].Items[0].Key != "x" || len(b2.Sections[2].Items) != 1 {
-		t.Fatalf("bad move:\n%s", got)
-	}
-}
-
-func TestDiffNamesTickAndAnswer(t *testing.T) {
-	old := "## 🧠 Needs you\n\n- [ ] Ship it\n- Pick\n  Ask: yes | no\n"
-	next := "## 🧠 Needs you\n\n- [x] Ship it\n- Pick\n  Ask: yes | no\n  Answer: no\n"
+func TestDiffNamesTickAndReply(t *testing.T) {
+	old := "## 🧠 Needs you\n\n- Ship it\n- Pick\n  Ask: which?\n"
+	next := "## 🧠 Needs you\n\n- [x] Ship it\n- Pick\n  Ask: which?\n  Answer: the first\n"
 	ob, _ := parseBoard(old)
 	nb, _ := parseBoard(next)
 	got := strings.Join(semanticDiff(ob, nb), "\n")
-	for _, want := range []string{`edited 🧠: "Ship it" — ticked`, `edited 🧠: "Pick" — replied "no"`} {
+	for _, want := range []string{`edited 🧠: "Ship it" — ticked`, `edited 🧠: "Pick" — replied "the first"`} {
 		if !strings.Contains(got, want) {
 			t.Fatalf("missing %q in:\n%s", want, got)
 		}
 	}
+	back, _ := parseBoard(old)
+	if got := strings.Join(semanticDiff(nb, back), "\n"); !strings.Contains(got, `"Ship it" — unticked`) {
+		t.Fatalf("untick to a plain bullet must still be reported:\n%s", got)
+	}
 }
diff --git a/interact.go b/interact.go
index 2ecb56d..c4aaf23 100644
--- a/interact.go
+++ b/interact.go
@@ -1,7 +1,7 @@
-// interact.go — the viewer's item cursor: pick a board item, then tick it,
-// answer its Ask: prompt, or send it to ✅ Done. Keyboard-first; mouse
-// clicks work only while mouse mode (M) is on, so native text selection and
-// clickable links stay the default.
+// interact.go — the viewer's channel back to the agent. Select an item, tick
+// its bullet, or reply to the agent's question; each is one line written to
+// the board, and the agent's hook reads it. Mouse clicks are on by default;
+// every action has a key too. Nothing here moves an item between sections.
 package main
 
 import (
@@ -10,20 +10,8 @@ import (
 	"strings"
 
 	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
 )
 
-// typingStyle is the reply being typed under an item.
-var typingStyle = lipgloss.NewStyle().Bold(true).
-	Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#E5C07B"))
-
-// hoverChip is the button under the pointer: the rendered line and which
-// button's text. line is -1 when the pointer is on none.
-type hoverChip struct {
-	line int
-	chip string
-}
-
 // undoEntry is one write made from the viewer: the file before and after, so
 // undo can restore it only while the file still reads as we left it.
 type undoEntry struct{ before, after string }
@@ -58,21 +46,13 @@ func itemStartLines(lines []string, headers []int, board Board) [][]int {
 }
 
 // applyItemHighlight tints the selected item's rendered lines.
-func applyItemHighlight(display string, starts [][]int, si, ii, total, width int) string {
+func applyItemHighlight(display string, starts [][]int, si, ii, width int) string {
 	if si < 0 || si >= len(starts) || ii < 0 || ii >= len(starts[si]) {
 		return display
 	}
 	lines := strings.Split(display, "\n")
-	from := starts[si][ii]
-	to := from + 1
-	if ii+1 < len(starts[si]) {
-		to = starts[si][ii+1]
-	} else {
-		for to < len(lines) && strings.TrimSpace(stripANSI(lines[to])) != "" {
-			to++
-		}
-	}
-	for i := from; i < to && i < len(lines); i++ {
+	end := itemEnd(lines, starts[si], ii)
+	for i := starts[si][ii]; i < end && i < len(lines); i++ {
 		if strings.TrimSpace(stripANSI(lines[i])) != "" {
 			lines[i] = applyLineBg(lines[i], colorCursorBg, width)
 		}
@@ -91,12 +71,9 @@ func (m model) selected() (BoardItem, string, bool) {
 	return s.Items[m.itemIdx], s.Label, true
 }
 
-// moveItemCursor steps to the next (+1) or previous (-1) selectable item,
-// wrapping, and scrolls it into view.
-func (m *model) moveItemCursor(delta int) {
-	type pos struct{ s, i int }
-	var all []pos
-	cur := -1
+// itemPositions lists every mapped, real item in reading order.
+func (m model) itemPositions() (all [][2]int, cur int) {
+	cur = -1
 	for si, starts := range m.itemStarts {
 		for ii := range starts {
 			if m.board.Sections[si].Items[ii].Key == emptySectionPlaceholder {
@@ -105,9 +82,21 @@ func (m *model) moveItemCursor(delta int) {
 			if si == m.itemSec && ii == m.itemIdx {
 				cur = len(all)
 			}
-			all = append(all, pos{si, ii})
+			all = append(all, [2]int{si, ii})
 		}
 	}
+	return all, cur
+}
+
+func (m *model) selectItem(si, ii int) {
+	m.itemSec, m.itemIdx, m.cursor = si, ii, si
+	m.recompose()
+	m.scrollTo(m.itemStarts[si][ii])
+}
+
+// moveItemCursor steps to the next (+1) or previous (-1) item, wrapping.
+func (m *model) moveItemCursor(delta int) {
+	all, cur := m.itemPositions()
 	if len(all) == 0 {
 		return
 	}
@@ -118,10 +107,30 @@ func (m *model) moveItemCursor(delta int) {
 	case delta < 0:
 		next = len(all) - 1
 	}
-	m.itemSec, m.itemIdx = all[next].s, all[next].i
-	m.cursor = m.itemSec
-	m.recompose()
-	m.scrollTo(m.itemStarts[m.itemSec][m.itemIdx])
+	m.selectItem(all[next][0], all[next][1])
+}
+
+// moveQuestionCursor selects the next (+1) or previous (-1) unanswered
+// question that is visible, wrapping, and says so when none is waiting.
+func (m *model) moveQuestionCursor(delta int) {
+	all, cur := m.itemPositions()
+	n := len(all)
+	for step := 1; step <= n; step++ {
+		var idx int
+		switch {
+		case cur >= 0:
+			idx = ((cur+delta*step)%n + n) % n
+		case delta > 0:
+			idx = step - 1
+		default:
+			idx = n - step
+		}
+		if isUnanswered(m.board.Sections[all[idx][0]].Items[all[idx][1]]) {
+			m.selectItem(all[idx][0], all[idx][1])
+			return
+		}
+	}
+	m.notice = "no questions waiting"
 }
 
 func (m *model) clearItemCursor() {
@@ -148,58 +157,61 @@ func (m *model) itemKey(key string) bool {
 	if !ok {
 		return false
 	}
-	opts := askOptions(it)
-	switch {
-	case key == "esc":
+	switch key {
+	case "esc":
 		m.clearItemCursor()
-		return true
-	case key == "x" && isCheckbox(it):
-		m.apply(label, it, replaceLines(toggleCheckbox), "")
-		return true
-	case key == "a":
-		m.typing, m.input = true, answerOf(it)
-		return true
-	case len(opts) > 0 && optionForKey(key, opts) != "":
-		choice := optionForKey(key, opts)
-		m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, choice) }), "replied "+choice)
-		return true
-	case key == "d":
-		m.apply(label, it, doneAndMove, "moved to Done")
-		m.itemSec, m.itemIdx = -1, -1
-		return true
-	}
-	return false
+	case "x":
+		m.tick(label, it)
+	case "a":
+		m.startReply(it)
+	default:
+		return false
+	}
+	return true
 }
 
-// optionForKey picks an Ask: option: a digit selects by position; y, n, and
-// d select "yes", "no", and "done" when the prompt offers them.
-func optionForKey(key string, opts []string) string {
-	if len(key) == 1 && key[0] >= '1' && key[0] <= '9' {
-		if n := int(key[0] - '1'); n < len(opts) {
-			return opts[n]
-		}
-		return ""
+func (m *model) tick(label string, it BoardItem) {
+	note := "ticked"
+	if isTicked(it) {
+		note = "unticked"
 	}
-	want := map[string]string{"y": "yes", "n": "no", "d": "done"}[key]
-	for _, o := range opts {
-		if want != "" && normalizeOption(o) == want {
-			return o
-		}
-	}
-	return ""
+	m.apply(label, it, replaceLines(toggleTick), note)
 }
 
-func doneLabel(b Board) string {
-	for _, s := range b.Sections {
-		if strings.HasSuffix(s.Label, "Done") {
-			return s.Label
+func (m *model) startReply(it BoardItem) {
+	m.typing, m.input = true, answerOf(it)
+	m.recompose()
+}
+
+// typeKey handles a keypress while a reply is being typed under an item:
+// text appends, backspace deletes, enter writes it, esc (or ctrl+c) abandons
+// it. Every key is consumed, so typing "q" or "x" into a reply never quits or
+// ticks anything.
+func (m *model) typeKey(msg tea.KeyMsg) {
+	switch msg.Type {
+	case tea.KeyEsc, tea.KeyCtrlC:
+		m.typing, m.input = false, ""
+	case tea.KeyEnter:
+		text := cleanAnswer(m.input)
+		it, label, ok := m.selected()
+		m.typing, m.input = false, ""
+		if ok && text != "" {
+			m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, text) }), "reply sent")
 		}
+	case tea.KeyBackspace:
+		if r := []rune(m.input); len(r) > 0 {
+			m.input = string(r[:len(r)-1])
+		}
+	case tea.KeySpace:
+		m.input += " "
+	case tea.KeyRunes:
+		m.input += string(msg.Runes)
 	}
-	return "✅ Done"
+	m.recompose() // the reply is drawn under its item, so redraw on every key
 }
 
-// apply writes one edit, then reloads so the pane shows the file as it now
-// is. A refused or failed write surfaces in the status bar.
+// apply writes one edit, remembers it for undo, then reloads so the pane shows
+// the file as it now is. A refused or failed write surfaces in the status bar.
 func (m *model) apply(label string, it BoardItem, fn func(string, Board, int, int) (string, error), note string) {
 	before, _ := os.ReadFile(m.path)
 	if err := editItem(m.path, label, it.Raw, fn); err != nil {
@@ -212,9 +224,6 @@ func (m *model) apply(label string, it BoardItem, fn func(string, Board, int, in
 	after, _ := os.ReadFile(m.path)
 	if string(before) != string(after) {
 		m.undo = append(m.undo, undoEntry{string(before), string(after)})
-		if note == "" {
-			note = "ticked"
-		}
 		note += " — u to undo"
 	}
 	m.notice = note
@@ -249,47 +258,48 @@ func (m *model) undoLast() {
 	m.reload(true)
 }
 
+// pendingQuestions counts unanswered questions outside the finished sections
+// — what is waiting on the human.
+func (m model) pendingQuestions() int {
+	n := 0
+	for _, s := range m.board.Sections {
+		if finishedLabel(s.Label) {
+			continue
+		}
+		for _, it := range s.Items {
+			if isUnanswered(it) {
+				n++
+			}
+		}
+	}
+	return n
+}
+
 // hint is the status-bar line shown while an item is selected.
 func (m model) hint() string {
 	it, _, ok := m.selected()
 	if !ok {
 		return ""
 	}
-	parts := []string{"[ prev · ] next", "a reply"}
-	if isCheckbox(it) {
-		parts = append(parts, "x tick")
+	tick := "x tick"
+	if isTicked(it) {
+		tick = "x untick"
 	}
-	if opts := askOptions(it); len(opts) > 0 {
-		var o []string
-		for i, v := range opts {
-			o = append(o, fmt.Sprintf("%d %s", i+1, v))
-		}
-		parts = append(parts, strings.Join(o, "  "))
+	reply := "a reply"
+	if answerOf(it) != "" {
+		reply = "a edit reply"
 	}
-	parts = append(parts, "d done", "esc")
-	if !m.mouse {
-		parts = append(parts, "M mouse on")
-	}
-	return strings.Join(parts, " · ")
+	return strings.Join([]string{"[ prev · ] next", tick, reply, "esc"}, " · ")
 }
 
-// itemAtLine finds the mapped, real item whose rendered lines — first line
-// through its button row — include line.
+// itemAtLine finds the mapped, real item whose rendered lines include line.
 func (m model) itemAtLine(line int) (si, ii, start int, ok bool) {
 	for si, starts := range m.itemStarts {
 		for ii, start := range starts {
-			end := start + 1
-			if ii+1 < len(starts) {
-				end = starts[ii+1]
-			} else {
-				for end < len(m.renderedLines) && strings.TrimSpace(stripANSI(m.renderedLines[end])) != "" {
-					end++
-				}
-			}
-			for end-1 > start && strings.TrimSpace(stripANSI(m.renderedLines[end-1])) == "" {
-				end-- // the blank spacer after an item is not part of it
+			if m.board.Sections[si].Items[ii].Key == emptySectionPlaceholder {
+				continue
 			}
-			if line >= start && line < end && m.board.Sections[si].Items[ii].Key != emptySectionPlaceholder {
+			if line >= start && line < itemEnd(m.renderedLines, starts, ii) {
 				return si, ii, start, true
 			}
 		}
@@ -297,9 +307,25 @@ func (m model) itemAtLine(line int) (si, ii, start int, ok bool) {
 	return 0, 0, 0, false
 }
 
-// mouseClick acts on a left click: a section header collapses, a button
-// acts, a checkbox ticks, and any other spot on an item selects it. Every
-// outcome says so in the status bar, so a click never looks ignored.
+// targetAt classifies what is under a click or the pointer: the bullet (the
+// first two columns of an item's first line) or the item's question line.
+func (m model) targetAt(x, line int) (si, ii int, kind hoverKind) {
+	si, ii, start, ok := m.itemAtLine(line)
+	if !ok {
+		return 0, 0, hoverNone
+	}
+	switch {
+	case line == start && x <= 1:
+		return si, ii, hoverBullet
+	case isQuestionLine(m.renderedLines[line]):
+		return si, ii, hoverQuestion
+	}
+	return si, ii, hoverNone
+}
+
+// mouseClick acts on a left click: a section header collapses, a bullet
+// ticks, a question opens a reply, and any other spot on an item selects it.
+// Every outcome says so in the status bar, so a click never looks ignored.
 func (m *model) mouseClick(x, y int) {
 	if y == m.vp.Height && len(m.undo) > 0 {
 		m.undoLast() // the status bar carries "u to undo"
@@ -317,41 +343,31 @@ func (m *model) mouseClick(x, y int) {
 			return
 		}
 	}
-	si, ii, start, ok := m.itemAtLine(line)
-	if !ok {
+	si, ii, kind := m.targetAt(x, line)
+	if _, _, _, ok := m.itemAtLine(line); !ok {
 		m.notice = fmt.Sprintf("click %d,%d — nothing to click on that line", x, y)
 		return
 	}
-	m.itemSec, m.itemIdx, m.cursor = si, ii, si
-	m.recompose()
+	m.selectItem(si, ii)
 	it, label, _ := m.selected()
-	switch kind, opt, hit := chipAt(it, m.renderedLines[line], x); {
-	case hit && kind == chipReply:
-		m.typing, m.input = true, answerOf(it)
-		m.recompose()
-	case hit && kind == chipDone:
-		m.apply(label, it, doneAndMove, "moved to Done")
-		m.itemSec, m.itemIdx = -1, -1
-	case hit:
-		m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, opt) }), "replied "+opt)
-	case x <= 1 && line == start && isCheckbox(it):
-		m.apply(label, it, replaceLines(toggleCheckbox), "")
+	switch kind {
+	case hoverBullet:
+		m.tick(label, it)
+	case hoverQuestion:
+		m.startReply(it)
 	default:
-		m.notice = fmt.Sprintf("click %d,%d — item selected; the buttons under it are the clickable part", x, y)
+		m.notice = "item selected — click its bullet to tick, its ? question to reply"
 	}
 }
 
-// setHover tracks the button under the pointer so it can be painted; it
-// re-renders only when the button changes.
+// setHover tracks what is under the pointer so it can be painted; it
+// re-renders only when the target changes.
 func (m *model) setHover(x, y int) {
-	next := hoverChip{line: -1}
+	next := hoverTarget{line: -1}
 	if y >= 0 && y < m.vp.Height {
 		line := y + m.vp.YOffset
-		if si, ii, _, ok := m.itemAtLine(line); ok {
-			it := m.board.Sections[si].Items[ii]
-			if c, hit := chipTextAt(it, m.renderedLines[line], x); hit {
-				next = hoverChip{line: line, chip: c}
-			}
+		if _, _, kind := m.targetAt(x, line); kind != hoverNone {
+			next = hoverTarget{line: line, kind: kind}
 		}
 	}
 	if next != m.hover {
@@ -360,154 +376,47 @@ func (m *model) setHover(x, y int) {
 	}
 }
 
-// typingRow returns the line that replaces the selected item's button row
-// while a reply is being typed, so the text appears where the click was.
-func (m model) typingRow(width int) (line int, text string, ok bool) {
-	if !m.typing {
-		return 0, "", false
-	}
-	si, ii, start, found := -1, -1, 0, false
-	if it, _, sel := m.selected(); sel {
-		_ = it
-		si, ii = m.itemSec, m.itemIdx
-		if m.itemSec < len(m.itemStarts) && m.itemIdx < len(m.itemStarts[m.itemSec]) {
-			start, found = m.itemStarts[si][ii], true
+// typingRow finds where the reply being typed is drawn: on the item's reply
+// line when it has one, otherwise as a new line after its last line. insert
+// says which.
+func (m model) typingRow(width int) (line int, text string, insert, ok bool) {
+	if !m.typing || m.itemSec < 0 || m.itemSec >= len(m.itemStarts) || m.itemIdx >= len(m.itemStarts[m.itemSec]) {
+		return 0, "", false, false
+	}
+	ss := m.itemStarts[m.itemSec]
+	end := itemEnd(m.renderedLines, ss, m.itemIdx)
+	const hint = "⏎ send · esc cancel"
+	showHint := width >= 44
+	room := max(4, width-8)
+	if showHint {
+		room = max(4, width-8-visibleWidth(hint)-2)
+	}
+	shown := m.input
+	if shown == "" {
+		shown = "type your reply…"
+	}
+	for visibleWidth(shown) > room && shown != "" {
+		shown = string([]rune(shown)[1:])
+	}
+	row := typingStyle.Render(" " + replyPrefix + shown + "▌ ")
+	if showHint {
+		row += "  " + hintStyle.Render(hint)
+	}
+	for l := ss[m.itemIdx] + 1; l < end; l++ {
+		if strings.HasPrefix(strings.TrimRight(stripANSI(m.renderedLines[l]), " "), replyPrefix) {
+			return l, row, false, true
 		}
 	}
-	if !found {
-		return 0, "", false
-	}
-	for l := start; l < len(m.renderedLines); l++ {
-		if strings.Contains(stripANSI(m.renderedLines[l]), doneChip) {
-			const hint = "⏎ send · esc cancel"
-			showHint := width >= 44
-			room := max(4, width-8)
-			if showHint {
-				room = max(4, width-8-visibleWidth(hint)-2)
-			}
-			shown := m.input
-			if shown == "" {
-				shown = "type your reply…"
-			}
-			for visibleWidth(shown) > room && shown != "" {
-				shown = string([]rune(shown)[1:])
-			}
-			row := "  " + typingStyle.Render(" 💬 "+shown+"▌ ")
-			if showHint {
-				row += "  " + buttonRestStyle.Render(hint)
-			}
-			return l, row, true
-		}
-	}
-	return 0, "", false
+	return end, row, true, true
 }
 
 func (m *model) toggleMouse() tea.Cmd {
 	m.mouse = !m.mouse
-	m.hover = hoverChip{line: -1}
+	m.hover = hoverTarget{line: -1}
 	if m.mouse {
-		m.notice = "mouse on — click buttons, boxes, items, headers (M to release)"
+		m.notice = "mouse on — click a bullet to tick, a ? question to reply (M to release)"
 		return tea.EnableMouseAllMotion
 	}
 	m.notice = "mouse off — native text selection restored (M to click again)"
 	return tea.DisableMouse
 }
-
-// typeKey handles a keypress while an answer is being typed in the status
-// bar: text appends, backspace deletes, enter writes the answer, esc (or
-// ctrl+c) abandons it. Every key is consumed, so typing "q" or "d" into an
-// answer never quits or moves anything.
-func (m *model) typeKey(msg tea.KeyMsg) {
-	switch msg.Type {
-	case tea.KeyEsc, tea.KeyCtrlC:
-		m.typing, m.input = false, ""
-	case tea.KeyEnter:
-		text := cleanAnswer(m.input)
-		m.typing, m.input = false, ""
-		if it, label, ok := m.selected(); ok && text != "" {
-			m.apply(label, it, replaceLines(func(l []string) ([]string, error) { return setAnswer(l, text) }), "reply sent")
-		}
-	case tea.KeyBackspace:
-		if r := []rune(m.input); len(r) > 0 {
-			m.input = string(r[:len(r)-1])
-		}
-	case tea.KeySpace:
-		m.input += " "
-	case tea.KeyRunes:
-		m.input += string(msg.Runes)
-	}
-	m.recompose() // the reply is drawn under its item, so redraw on every key
-}
-
-// pendingQuestions counts unanswered Ask: items outside the finished
-// sections — what is waiting on the human.
-func (m model) pendingQuestions() int {
-	n := 0
-	for _, s := range m.board.Sections {
-		if strings.HasSuffix(s.Label, "Done") || strings.HasSuffix(s.Label, "Shipped") {
-			continue
-		}
-		for _, it := range s.Items {
-			if isUnanswered(it) {
-				n++
-			}
-		}
-	}
-	return n
-}
-
-// moveQuestionCursor selects the next (+1) or previous (-1) unanswered
-// question that is visible, wrapping, and says so when none is waiting.
-func (m *model) moveQuestionCursor(delta int) {
-	type pos struct{ s, i int }
-	var all []pos
-	cur := -1
-	for si, starts := range m.itemStarts {
-		for ii := range starts {
-			if si == m.itemSec && ii == m.itemIdx {
-				cur = len(all)
-			}
-			all = append(all, pos{si, ii})
-		}
-	}
-	n := len(all)
-	for step := 1; step <= n; step++ {
-		var idx int
-		switch {
-		case cur >= 0:
-			idx = ((cur+delta*step)%n + n) % n
-		case delta > 0:
-			idx = step - 1
-		default:
-			idx = n - step
-		}
-		p := all[idx]
-		if isUnanswered(m.board.Sections[p.s].Items[p.i]) {
-			m.itemSec, m.itemIdx, m.cursor = p.s, p.i, p.s
-			m.recompose()
-			m.scrollTo(m.itemStarts[p.s][p.i])
-			return
-		}
-	}
-	m.notice = "no questions waiting"
-}
-
-// doneAndMove records "✅ Done" as the reply when the human has said nothing
-// else — so the agent's hook can tell a human finished it — then moves the
-// item to ✅ Done.
-func doneAndMove(raw string, b Board, si, ii int) (string, error) {
-	it := b.Sections[si].Items[ii]
-	if answerOf(it) == "" {
-		var err error
-		raw, err = replaceLines(func(l []string) ([]string, error) { return setAnswer(l, "✅ Done") })(raw, b, si, ii)
-		if err != nil {
-			return "", err
-		}
-		nb, ok := parseBoard(raw)
-		if !ok {
-			return "", errBoardChanged
-		}
-		b = nb
-	}
-	return moveItem(raw, b, si, ii, doneLabel(b))
-}
diff --git a/interact_test.go b/interact_test.go
index 6cb0007..74dc32a 100644
--- a/interact_test.go
+++ b/interact_test.go
@@ -22,6 +22,18 @@ func press(t *testing.T, m model, keys ...string) model {
 	return m
 }
 
+func typeText(t *testing.T, m model, s string) model {
+	t.Helper()
+	next, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(s)})
+	return next.(model)
+}
+
+func special(t *testing.T, m model, k tea.KeyType) model {
+	t.Helper()
+	next, _ := m.Update(tea.KeyMsg{Type: k})
+	return next.(model)
+}
+
 func interactModel(t *testing.T) (model, string) {
 	t.Helper()
 	p := filepath.Join(t.TempDir(), "sidecar.md")
@@ -29,7 +41,7 @@ func interactModel(t *testing.T) (model, string) {
 	return testModel(t, p), p
 }
 
-func TestItemStartLinesMapEveryItem(t *testing.T) {
+func TestItemStartLinesMapEveryOpenItem(t *testing.T) {
 	m, _ := interactModel(t)
 	got := 0
 	for si, starts := range m.itemStarts {
@@ -43,52 +55,66 @@ func TestItemStartLinesMapEveryItem(t *testing.T) {
 	}
 }
 
-func TestTickItemFromKeyboard(t *testing.T) {
+func TestTickFromKeyboardBothWays(t *testing.T) {
 	m, p := interactModel(t)
 	m = press(t, m, "]", "x")
-	if got := readFile(t, p); !strings.Contains(got, "- [x] Ship it") {
-		t.Fatalf("not ticked:\n%s", got)
+	if !strings.Contains(readFile(t, p), "- [x] Ship it") {
+		t.Fatalf("not ticked:\n%s", readFile(t, p))
 	}
-	m = press(t, m, "x")
-	if got := readFile(t, p); !strings.Contains(got, "- [ ] Ship it") {
+	if !strings.Contains(m.notice, "ticked") {
+		t.Fatalf("notice %q", m.notice)
+	}
+	press(t, m, "x")
+	if got := readFile(t, p); strings.Contains(got, "[x]") || !strings.Contains(got, "- Ship it") {
 		t.Fatalf("not unticked:\n%s", got)
 	}
 }
 
-func TestAnswerAskFromKeyboard(t *testing.T) {
+func TestReplyFromKeyboard(t *testing.T) {
 	m, p := interactModel(t)
-	m = press(t, m, "]", "]", "n")
-	if got := readFile(t, p); !strings.Contains(got, "  Ask: yes | no | done\n  Answer: no\n") {
-		t.Fatalf("not answered:\n%s", got)
+	m = press(t, m, "]", "]", "a")
+	if !m.typing {
+		t.Fatal("a should open the reply line")
+	}
+	// q, x, and ] are text while typing — they must not quit, tick, or select.
+	m = typeText(t, m, "qx] nap")
+	m = special(t, m, tea.KeySpace)
+	m = typeText(t, m, "time")
+	m = special(t, m, tea.KeyBackspace)
+	m = special(t, m, tea.KeyEnter)
+	got := readFile(t, p)
+	if !strings.Contains(got, "  Ask: What should we call it?\n  Answer: qx] nap tim\n  Next: answer") {
+		t.Fatalf("reply not written under the question:\n%s", got)
 	}
-	press(t, m, "1")
-	if got := readFile(t, p); strings.Count(got, "Answer:") != 1 || !strings.Contains(got, "Answer: yes") {
-		t.Fatalf("answer not replaced:\n%s", got)
+	if m.typing || m.input != "" {
+		t.Fatal("typing state should clear after enter")
 	}
 }
 
-func TestDoneKeyOnAskAnswersDoneNotMove(t *testing.T) {
+func TestReplyEscAbandonsAndBlankWritesNothing(t *testing.T) {
 	m, p := interactModel(t)
-	press(t, m, "]", "]", "d")
-	got := readFile(t, p)
-	if !strings.Contains(got, "Answer: done") || strings.Count(got, "Pick a path") != 1 {
-		t.Fatalf("d on a prompt offering done should answer it:\n%s", got)
+	m = press(t, m, "]", "a")
+	m = typeText(t, m, "nope")
+	m = special(t, m, tea.KeyEsc)
+	if m.typing || strings.Contains(readFile(t, p), "nope") {
+		t.Fatal("esc must abandon the reply")
 	}
-	b, _ := parseBoard(got)
-	if len(b.Sections[2].Items) != 1 {
-		t.Fatalf("item must not move:\n%s", got)
+	m = press(t, m, "a")
+	m = typeText(t, m, "   ")
+	special(t, m, tea.KeyEnter)
+	if readFile(t, p) != editBoard {
+		t.Fatal("a blank reply must not write")
 	}
 }
 
-func TestDoneKeyMovesPlainItem(t *testing.T) {
-	m, p := interactModel(t)
-	m = press(t, m, "]", "d")
-	b, _ := parseBoard(readFile(t, p))
-	if len(b.Sections[2].Items) != 2 || b.Sections[0].Items[0].Key != "Pick a path" {
-		t.Fatalf("not moved:\n%s", readFile(t, p))
-	}
-	if m.itemSec != -1 {
-		t.Fatal("cursor should clear after a move")
+func TestReplyPrefillsTheCurrentReply(t *testing.T) {
+	m, _ := interactModel(t)
+	m = press(t, m, "]", "]", "a")
+	m = typeText(t, m, "first")
+	m = special(t, m, tea.KeyEnter)
+	m = press(t, m, "]", "]", "a") // reselect and edit
+	if m.input != "first" {
+		t.Fatalf("edit should prefill, got %q", m.input)
 	}
 }
 
@@ -100,8 +126,19 @@ func TestEditRefusedWhenAgentChangedItem(t *testing.T) {
 	if !strings.Contains(m.notice, "changed") {
 		t.Fatalf("notice %q", m.notice)
 	}
-	if got := readFile(t, p); strings.Contains(got, "[x]") {
-		t.Fatalf("stale edit was written:\n%s", got)
+	if strings.Contains(readFile(t, p), "[x]") {
+		t.Fatal("stale edit was written")
+	}
+}
+
+func TestViewerNeverMovesItems(t *testing.T) {
+	m, p := interactModel(t)
+	m.mouse = true
+	press(t, m, "]", "d", "x", "a", "esc")
+	got := readFile(t, p)
+	b, _ := parseBoard(got)
+	if len(b.Sections[0].Items) != 2 || len(b.Sections[2].Items) != 1 {
+		t.Fatalf("no key or click may move an item between sections:\n%s", got)
 	}
 }
 
@@ -113,23 +150,6 @@ func TestEscClearsItemCursor(t *testing.T) {
 	}
 }
 
-func TestMouseClickTicksBoxOnlyInMouseMode(t *testing.T) {
-	m, p := interactModel(t)
-	line := m.itemStarts[0][0]
-	click := tea.MouseMsg{X: 0, Y: line - m.vp.YOffset, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft}
-	next, _ := m.Update(click)
-	m = next.(model)
-	if strings.Contains(readFile(t, p), "[x]") {
-		t.Fatal("click must be ignored while mouse mode is off")
-	}
-	m = press(t, m, "M")
-	next, _ = m.Update(click)
-	if !strings.Contains(readFile(t, p), "- [x] Ship it") {
-		t.Fatal("click on the box should tick in mouse mode")
-	}
-	_ = next
-}
-
 func TestEditPreservesFileMode(t *testing.T) {
 	m, p := interactModel(t)
 	os.Chmod(p, 0o600)
@@ -139,15 +159,9 @@ func TestEditPreservesFileMode(t *testing.T) {
 	}
 }
 
-func TestMouseClickOnStatusBarRowIgnored(t *testing.T) {
-	m, p := interactModel(t)
-	m = press(t, m, "M")
-	m.vp.SetYOffset(0)
-	// The status bar row sits at y == viewport height; it must not map to
-	// content below the fold even when a checkbox starts on that line.
-	m.mouseClick(0, m.vp.Height)
-	if strings.Contains(readFile(t, p), "[x]") || m.itemSec != -1 {
-		t.Fatal("status bar click acted on an item")
+func TestCleanAnswerIsOneLine(t *testing.T) {
+	if got := cleanAnswer(" a\nb\t\x1b[31mc  d "); got != "a b [31mc d" {
+		t.Fatalf("%q", got)
 	}
 }
 
@@ -156,19 +170,19 @@ const questionBoard = `# Board
 ## 🧠 Needs you
 
 - Which name?
-  Ask:
+  Ask: What should we call it?
   Next: answer
 - Merge now?
-  Ask: yes | no
+  Ask: Anything blocking the merge?
   Next: answer
 - Old question
-  Ask: yes | no
+  Ask: Fine?
   Answer: yes
 
 ## ✅ Done
 
 - shipped
-  Ask: yes | no
+  Ask: Was it fine?
 `
 
 func questionModel(t *testing.T) (model, string) {
@@ -178,75 +192,6 @@ func questionModel(t *testing.T) (model, string) {
 	return testModel(t, p), p
 }
 
-func typeText(t *testing.T, m model, s string) model {
-	t.Helper()
-	next, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(s)})
-	return next.(model)
-}
-
-func special(t *testing.T, m model, k tea.KeyType) model {
-	t.Helper()
-	next, _ := m.Update(tea.KeyMsg{Type: k})
-	return next.(model)
-}
-
-func TestFreeTextAnswer(t *testing.T) {
-	m, p := questionModel(t)
-	m = press(t, m, "]", "a")
-	if !m.typing {
-		t.Fatal("a on an Ask: item should open the answer line")
-	}
-	// q, d, and ] are text while typing — they must not quit, move, or select.
-	m = typeText(t, m, "qd] nap")
-	m = special(t, m, tea.KeySpace)
-	m = typeText(t, m, "time")
-	m = special(t, m, tea.KeyBackspace)
-	m = special(t, m, tea.KeyEnter)
-	got := readFile(t, p)
-	if !strings.Contains(got, "  Ask:\n  Answer: qd] nap tim\n  Next: answer") {
-		t.Fatalf("answer not written under the Ask: line:\n%s", got)
-	}
-	if m.typing || m.input != "" {
-		t.Fatal("typing state should clear after enter")
-	}
-}
-
-func TestFreeTextEscAbandons(t *testing.T) {
-	m, p := questionModel(t)
-	m = press(t, m, "]", "a")
-	m = typeText(t, m, "nope")
-	m = special(t, m, tea.KeyEsc)
-	if m.typing || strings.Contains(readFile(t, p), "Answer: nope") {
-		t.Fatal("esc must abandon the answer")
-	}
-}
-
-func TestFreeTextEmptyWritesNothing(t *testing.T) {
-	m, p := questionModel(t)
-	m = press(t, m, "]", "a")
-	m = typeText(t, m, "  ")
-	special(t, m, tea.KeyEnter)
-	if readFile(t, p) != questionBoard {
-		t.Fatal("blank answer must not write")
-	}
-}
-
-func TestFreeTextOnQuestionWithOptions(t *testing.T) {
-	m, p := questionModel(t)
-	m = press(t, m, "]", "]", "a")
-	m = typeText(t, m, "yes, after lunch")
-	special(t, m, tea.KeyEnter)
-	if !strings.Contains(readFile(t, p), "  Answer: yes, after lunch\n") {
-		t.Fatalf("custom answer on an optioned question:\n%s", readFile(t, p))
-	}
-}
-
-func TestCleanAnswerIsOneLine(t *testing.T) {
-	if got := cleanAnswer(" a\nb\t\x1b[31mc  d "); got != "a b [31mc d" {
-		t.Fatalf("%q", got)
-	}
-}
-
 func TestPendingQuestionsCountsOpenOnesOutsideDone(t *testing.T) {
 	m, _ := questionModel(t)
 	if got := m.pendingQuestions(); got != 2 {
@@ -259,17 +204,12 @@ func TestPendingQuestionsCountsOpenOnesOutsideDone(t *testing.T) {
 
 func TestQuestionNavigationSkipsAnsweredAndWraps(t *testing.T) {
 	m, _ := questionModel(t)
-	m = press(t, m, "}")
-	if it, _, _ := m.selected(); it.Key != "Which name?" {
-		t.Fatalf("first: %q", it.Key)
-	}
-	m = press(t, m, "}")
-	if it, _, _ := m.selected(); it.Key != "Merge now?" {
-		t.Fatalf("second: %q", it.Key)
-	}
-	m = press(t, m, "}")
-	if it, _, _ := m.selected(); it.Key != "Which name?" {
-		t.Fatalf("wrap: %q", it.Key)
+	want := []string{"Which name?", "Merge now?", "Which name?"}
+	for i, w := range want {
+		m = press(t, m, "}")
+		if it, _, _ := m.selected(); it.Key != w {
+			t.Fatalf("step %d: %q, want %q", i, it.Key, w)
+		}
 	}
 	m = press(t, m, "{")
 	if it, _, _ := m.selected(); it.Key != "Merge now?" {
@@ -277,20 +217,10 @@ func TestQuestionNavigationSkipsAnsweredAndWraps(t *testing.T) {
 	}
 }
 
-func TestQuestionNavigationFromAnsweredItemSteps(t *testing.T) {
-	m, _ := questionModel(t)
-	m = press(t, m, "]", "]", "]") // the answered item
-	m = press(t, m, "}")
-	if it, _, _ := m.selected(); it.Key != "Which name?" {
-		t.Fatalf("next from answered wraps to first question, got %q", it.Key)
-	}
-}
-
 func TestQuestionNavigationNoneWaiting(t *testing.T) {
 	p := filepath.Join(t.TempDir(), "sidecar.md")
 	writeFile(t, p, "## 🧠 Needs you\n\n- just a note\n")
-	m := testModel(t, p)
-	m = press(t, m, "}")
+	m := press(t, testModel(t, p), "}")
 	if !strings.Contains(m.notice, "no questions") {
 		t.Fatalf("notice %q", m.notice)
 	}
diff --git a/main.go b/main.go
index 3a6cc61..ba014f8 100644
--- a/main.go
+++ b/main.go
@@ -35,18 +35,13 @@ keys:  j/k, arrows, PgUp/PgDn, wheel        scroll
        g / G                                top / bottom
        tab / shift+tab                      move between sections
        enter / space                        collapse / expand section
-       ] / [                                select next / previous item
-       a                                    reply to the selected item (enter sends)
-       d                                    send the selected item to Done
-       x                                    tick a "- [ ]" item
-       1-9  or  y / n / d                   pick a choice from an "Ask: a | b" line
+       click a • bullet, or  ] / [ then x   tick it ✓ (again to untick)
+       click a ? question, or  a            answer the agent, in your own words
        } / {                                next / previous open question
+       u                                    undo the last change made from the viewer
        esc                                  deselect
        r                                    force reload
-       M                                    mouse on/off. On by default: click the
-                                              [ Done ] / [ Reply ] buttons, boxes, items,
-                                              and section headers. Shift-drag selects text.
-       u                                    undo the last change made from the viewer
+       M                                    mouse on/off. On by default; Shift-drag selects text.
        q                                    quit
 
 The file doesn't have to exist yet — sidecar waits for it and renders the
diff --git a/marks.go b/marks.go
new file mode 100644
index 0000000..c12451a
--- /dev/null
+++ b/marks.go
@@ -0,0 +1,186 @@
+// marks.go — how the human's side of the board is drawn. The file stays plain
+// markdown; at display time the viewer:
+//
+//   - shows an item's "Ask: …" line as "? …" in the accent color — a question
+//     you can click, or answer with a;
+//   - shows the "Answer: …" line as "↳ …";
+//   - puts one blank line between items;
+//   - paints the bullet, or the question, solid under the pointer.
+//
+// The bullet is the control: a click turns • into ✓ (the file gets "- [x]")
+// and a second click turns it back. The viewer never moves an item between
+// sections — the agent owns that; this is only the channel back to it.
+package main
+
+import (
+	"strings"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+var (
+	questionStyle    = lipgloss.NewStyle().Foreground(lipgloss.Color("#E5C07B"))
+	questionHotStyle = lipgloss.NewStyle().Bold(true).Underline(true).Foreground(lipgloss.Color("#E5C07B"))
+	replyLineStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("#98C379"))
+	bulletHotStyle   = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#E5C07B"))
+	typingStyle      = lipgloss.NewStyle().Bold(true).
+				Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#E5C07B"))
+	hintStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#8B93A5"))
+)
+
+const (
+	questionPrefix = "? "
+	replyPrefix    = "↳ "
+)
+
+// finishedLabel reports a ✅ Done or 📦 Shipped heading, with or without the
+// " (N)" item count the display rewrite appends.
+func finishedLabel(label string) bool {
+	label = strings.TrimSpace(label)
+	if i := strings.LastIndex(label, " ("); i >= 0 && strings.HasSuffix(label, ")") {
+		label = label[:i]
+	}
+	return strings.HasSuffix(label, "Done") || strings.HasSuffix(label, "Shipped")
+}
+
+// displayText is the board as rendered: collapsed sections dropped and counts
+// added, then each item's Ask: line redrawn as a question and its Answer: line
+// as a reply. The line count never changes.
+func displayText(raw string, board Board, collapsed map[string]bool) string {
+	collapsedRaw := applyCollapse(raw, board, collapsed)
+	b, ok := parseBoard(collapsedRaw)
+	if !ok {
+		return collapsedRaw
+	}
+	lines := strings.Split(collapsedRaw, "\n")
+	for _, s := range b.Sections {
+		for _, it := range s.Items {
+			for i := it.StartLine + 1; i <= it.EndLine && i < len(lines); i++ {
+				t := strings.TrimSpace(lines[i])
+				indent := lines[i][:len(lines[i])-len(strings.TrimLeft(lines[i], " \t"))]
+				switch {
+				case strings.HasPrefix(t, "Ask:"):
+					lines[i] = indent + questionPrefix + strings.TrimSpace(strings.TrimPrefix(t, "Ask:"))
+				case strings.HasPrefix(t, "Answer:"):
+					lines[i] = indent + replyPrefix + strings.TrimSpace(strings.TrimPrefix(t, "Answer:"))
+				}
+			}
+		}
+	}
+	return strings.Join(lines, "\n")
+}
+
+// renderBoardLines renders the display markdown, colors the question and
+// reply lines, and spaces the items. board must be the parse of the file the
+// display text came from, so items line up with the rendered bullets.
+func renderBoardLines(display string, board Board, width int) ([]string, error) {
+	rendered, err := renderMarkdown(display, width, true)
+	if err != nil {
+		return nil, err
+	}
+	lines := strings.Split(rendered, "\n")
+	if len(board.Sections) == 0 {
+		return lines, nil
+	}
+	starts := itemStartLines(lines, sectionHeaderLines(lines), board)
+	return spaceItems(colorMarks(lines, starts), starts), nil
+}
+
+// colorMarks paints each question in the accent color and each reply green.
+// Only lines inside a mapped item are touched, so body text that happens to
+// begin "? " elsewhere is left alone.
+func colorMarks(lines []string, starts [][]int) []string {
+	out := append([]string(nil), lines...)
+	for _, ss := range starts {
+		for ii, start := range ss {
+			end := itemEnd(lines, ss, ii)
+			for l := start + 1; l < end && l < len(out); l++ {
+				t := strings.TrimRight(stripANSI(out[l]), " ")
+				switch {
+				case strings.HasPrefix(t, questionPrefix):
+					out[l] = questionStyle.Render(t)
+				case strings.HasPrefix(t, replyPrefix):
+					out[l] = replyLineStyle.Render(t)
+				}
+			}
+		}
+	}
+	return out
+}
+
+// itemEnd is the index one past an item's last rendered line: the next
+// item's start, or the first blank line, backed up over trailing blanks.
+func itemEnd(lines []string, starts []int, ii int) int {
+	start := starts[ii]
+	end := start + 1
+	if ii+1 < len(starts) {
+		end = starts[ii+1]
+	} else {
+		for end < len(lines) && strings.TrimSpace(stripANSI(lines[end])) != "" {
+			end++
+		}
+	}
+	for end-1 > start && strings.TrimSpace(stripANSI(lines[end-1])) == "" {
+		end--
+	}
+	return end
+}
+
+// spaceItems puts one blank line after every item whose next line is not
+// already blank, so a long list does not read as a wall.
+func spaceItems(lines []string, starts [][]int) []string {
+	insert := map[int]bool{}
+	for _, ss := range starts {
+		for ii := range ss {
+			end := itemEnd(lines, ss, ii)
+			if end < len(lines) && strings.TrimSpace(stripANSI(lines[end])) != "" {
+				insert[end] = true
+			}
+		}
+	}
+	var out []string
+	for i, ln := range lines {
+		if insert[i] {
+			out = append(out, "")
+		}
+		out = append(out, ln)
+	}
+	return out
+}
+
+// hoverKind is what the pointer is over.
+type hoverKind int
+
+const (
+	hoverNone hoverKind = iota
+	hoverBullet
+	hoverQuestion
+)
+
+// hoverTarget is the clickable thing under the pointer: which rendered line
+// and what it is.
+type hoverTarget struct {
+	line int
+	kind hoverKind
+}
+
+// isQuestionLine reports a rendered line that is an item's question.
+func isQuestionLine(rendered string) bool {
+	return strings.HasPrefix(strings.TrimRight(stripANSI(rendered), " "), questionPrefix)
+}
+
+// paintHover repaints the hovered bullet or question on a copy-safe line: the
+// bullet glyph turns solid, the question goes bold and underlined.
+func paintHover(line string, kind hoverKind) string {
+	switch kind {
+	case hoverBullet:
+		for _, g := range []string{"•", "✓", "□"} {
+			if strings.Contains(line, g) {
+				return strings.Replace(line, g, bulletHotStyle.Render(g), 1)
+			}
+		}
+	case hoverQuestion:
+		return questionHotStyle.Render(strings.TrimRight(stripANSI(line), " "))
+	}
+	return line
+}
diff --git a/marks_test.go b/marks_test.go
new file mode 100644
index 0000000..d863f5b
--- /dev/null
+++ b/marks_test.go
@@ -0,0 +1,305 @@
+package main
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/muesli/termenv"
+)
+
+const marksBoard = `# Board
+
+## 🧠 Needs you
+
+- Config rewritten — the deploy script now reads the new keys.
+  Ask: What did you change on your side in the meantime?
+  Next: reply
+
+## 🤖 Agent queue
+
+- Second item.
+
+## ✅ Done
+
+- old
+`
+
+func marksModel(t *testing.T) (model, string) {
+	t.Helper()
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, marksBoard)
+	m := testModel(t, p)
+	m.mouse = true
+	return m, p
+}
+
+// plainLines renders a board the way the viewer does and strips the color.
+func plainLines(t *testing.T, raw string, collapsed map[string]bool, width int) []string {
+	t.Helper()
+	b, _ := parseBoard(raw)
+	lines, err := renderBoardLines(displayText(raw, b, collapsed), b, width)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for i := range lines {
+		lines[i] = strings.TrimRight(stripANSI(lines[i]), " ")
+	}
+	return lines
+}
+
+func lineWith(m model, text string) (int, string) {
+	for i, ln := range m.renderedLines {
+		if plain := stripANSI(ln); strings.Contains(plain, text) {
+			return i, plain
+		}
+	}
+	return -1, ""
+}
+
+func mouseAt(t *testing.T, m model, text string, x int, action tea.MouseAction, b tea.MouseButton) model {
+	t.Helper()
+	i, plain := lineWith(m, text)
+	if i < 0 {
+		t.Fatalf("no rendered line contains %q", text)
+	}
+	col := visibleWidth(plain[:strings.Index(plain, text)]) + x
+	next, _ := m.Update(tea.MouseMsg{X: col, Y: i - m.vp.YOffset, Action: action, Button: b})
+	return next.(model)
+}
+
+func clickAt(t *testing.T, m model, text string, x int) model {
+	return mouseAt(t, m, text, x, tea.MouseActionPress, tea.MouseButtonLeft)
+}
+
+func TestAskAndAnswerLinesAreRedrawn(t *testing.T) {
+	raw := marksBoard + ""
+	raw = strings.Replace(raw, "  Next: reply", "  Answer: restarted the worker\n  Next: reply", 1)
+	got := strings.Join(plainLines(t, raw, nil, 80), "\n")
+	if !strings.Contains(got, "? What did you change on your side in the meantime?") || !strings.Contains(got, "↳ restarted the worker") {
+		t.Fatalf("question/reply not drawn:\n%s", got)
+	}
+	if strings.Contains(got, "Ask:") || strings.Contains(got, "Answer:") {
+		t.Fatalf("raw keywords leaked:\n%s", got)
+	}
+}
+
+func TestNoEmojiOrButtonsAreDrawnAroundItems(t *testing.T) {
+	got := strings.Join(plainLines(t, marksBoard, nil, 80), "\n")
+	for _, bad := range []string{"[ ", "💬", "Reply", "Done ]"} {
+		if strings.Contains(got, bad) {
+			t.Fatalf("%q must not appear in the item area:\n%s", bad, got)
+		}
+	}
+}
+
+func TestOneBlankLineSeparatesItems(t *testing.T) {
+	raw := "## 🧠 Needs you\n\n- first\n- second\n  more\n- third\n\n## ✅ Done\n\n- a\n- b\n"
+	text := strings.Join(plainLines(t, raw, nil, 60), "\n")
+	for _, pair := range [][2]string{{"• first", "• second"}, {"more", "• third"}, {"• a", "• b"}} {
+		a, b := strings.Index(text, pair[0]), strings.Index(text, pair[1])
+		if between := text[a:b]; !strings.Contains(between, "\n\n") || strings.Contains(between, "\n\n\n") {
+			t.Fatalf("want exactly one blank line between %q and %q, got %q\n%s", pair[0], pair[1], between, text)
+		}
+	}
+	if strings.Contains(text, "\n\n\n") {
+		t.Fatalf("no run of blank lines anywhere:\n%s", text)
+	}
+}
+
+func TestClickBulletTicksAndClickAgainUnticks(t *testing.T) {
+	m, p := marksModel(t)
+	m = clickAt(t, m, "• Config rewritten", 0)
+	if !strings.Contains(readFile(t, p), "- [x] Config rewritten") {
+		t.Fatalf("bullet click should tick:\n%s", readFile(t, p))
+	}
+	if v := stripANSI(m.vp.View()); !strings.Contains(v, "✓ Config rewritten") {
+		t.Fatalf("the bullet should now draw as ✓:\n%s", v)
+	}
+	m = clickAt(t, m, "✓ Config rewritten", 1)
+	if got := readFile(t, p); strings.Contains(got, "[x]") || !strings.Contains(got, "- Config rewritten") {
+		t.Fatalf("second click should untick to a plain bullet:\n%s", got)
+	}
+}
+
+func TestClickQuestionOpensInlineReply(t *testing.T) {
+	m, p := marksModel(t)
+	m = clickAt(t, m, "? What did you change", 4)
+	if !m.typing {
+		t.Fatal("clicking the question should open the reply line")
+	}
+	m = typeText(t, m, "Restarted the worker by hand")
+	if v := stripANSI(m.vp.View()); !strings.Contains(v, "↳ Restarted the worker by hand▌") || !strings.Contains(v, "⏎ send") {
+		t.Fatalf("reply should be typed under the question with a hint:\n%s", v)
+	}
+	special(t, m, tea.KeyEnter)
+	if got := readFile(t, p); !strings.Contains(got, "  Ask: What did you change on your side in the meantime?\n  Answer: Restarted the worker by hand\n") {
+		t.Fatalf("reply not written under the question:\n%s", got)
+	}
+}
+
+func TestEmptyReplyLineSaysWhatToDo(t *testing.T) {
+	m, _ := marksModel(t)
+	m = clickAt(t, m, "? What did you change", 4)
+	if v := stripANSI(m.vp.View()); !strings.Contains(v, "type your reply…") {
+		t.Fatalf("placeholder missing:\n%s", v)
+	}
+	m = special(t, m, tea.KeyEsc)
+	if v := stripANSI(m.vp.View()); strings.Contains(v, "type your reply") || strings.Contains(v, "↳") {
+		t.Fatalf("esc should remove the reply line:\n%s", v)
+	}
+}
+
+func TestReplyOnItemWithoutQuestionIsInsertedAfterIt(t *testing.T) {
+	m, p := marksModel(t)
+	m = press(t, m, "]", "]", "a") // "Second item."
+	m = typeText(t, m, "unprompted note")
+	var rows []string
+	for _, l := range strings.Split(stripANSI(m.vp.View()), "\n") {
+		rows = append(rows, strings.TrimRight(l, " "))
+	}
+	v := strings.Join(rows, "\n")
+	if !strings.Contains(v, "• Second item.\n ↳ unprompted note▌") {
+		t.Fatalf("typed line should appear under the item:\n%s", v)
+	}
+	special(t, m, tea.KeyEnter)
+	if got := readFile(t, p); !strings.Contains(got, "- Second item.\n  Answer: unprompted note\n") {
+		t.Fatalf("got:\n%s", got)
+	}
+}
+
+func TestClickElsewhereOnAnItemOnlySelectsAndExplains(t *testing.T) {
+	m, p := marksModel(t)
+	m = clickAt(t, m, "Next: reply", 0)
+	if m.itemSec < 0 || readFile(t, p) != marksBoard || !strings.Contains(m.notice, "click its bullet") {
+		t.Fatalf("a click off the controls should select and explain, notice %q", m.notice)
+	}
+}
+
+func TestClickIgnoredWhenMouseIsOff(t *testing.T) {
+	m, p := marksModel(t)
+	m.mouse = false
+	clickAt(t, m, "• Config rewritten", 0)
+	if readFile(t, p) != marksBoard {
+		t.Fatal("clicks must not act while mouse is off")
+	}
+}
+
+func TestNothingMovesBetweenSections(t *testing.T) {
+	m, p := marksModel(t)
+	m = clickAt(t, m, "• Config rewritten", 0)
+	m = clickAt(t, m, "? What did you change", 4)
+	m = typeText(t, m, "ok")
+	special(t, m, tea.KeyEnter)
+	b, _ := parseBoard(readFile(t, p))
+	if len(b.Sections[0].Items) != 1 || len(b.Sections[1].Items) != 1 || len(b.Sections[2].Items) != 1 {
+		t.Fatalf("the human never files items:\n%s", readFile(t, p))
+	}
+}
+
+func TestHoverPaintsBulletAndQuestion(t *testing.T) {
+	prev := lipgloss.ColorProfile()
+	lipgloss.SetColorProfile(termenv.TrueColor)
+	t.Cleanup(func() { lipgloss.SetColorProfile(prev) })
+	m, _ := marksModel(t)
+	m = press(t, m, "M", "M") // toggle off and back on: hover state resets cleanly
+	rest := m.vp.View()
+
+	m = mouseAt(t, m, "• Config rewritten", 0, tea.MouseActionMotion, tea.MouseButtonNone)
+	if m.hover.kind != hoverBullet || m.vp.View() == rest || !strings.Contains(m.vp.View(), bulletHotStyle.Render("•")) {
+		t.Fatalf("hovering the bullet should paint it solid (hover %+v)", m.hover)
+	}
+	m = mouseAt(t, m, "? What did you change", 4, tea.MouseActionMotion, tea.MouseButtonNone)
+	if m.hover.kind != hoverQuestion || !strings.Contains(m.vp.View(), "\x1b[4") && !strings.Contains(m.vp.View(), ";4;") && !strings.Contains(m.vp.View(), "[1;4") {
+		t.Fatalf("hovering the question should underline it (hover %+v)", m.hover)
+	}
+	m = mouseAt(t, m, "Next: reply", 0, tea.MouseActionMotion, tea.MouseButtonNone)
+	if m.hover.line != -1 || m.vp.View() != rest {
+		t.Fatal("moving off the controls should return everything to rest")
+	}
+}
+
+func TestHoverIgnoredWithMouseOff(t *testing.T) {
+	m, _ := marksModel(t)
+	m.mouse = false
+	m = mouseAt(t, m, "• Config rewritten", 0, tea.MouseActionMotion, tea.MouseButtonNone)
+	if m.hover.line != -1 {
+		t.Fatal("no hover while mouse is off")
+	}
+}
+
+func TestUndoRestoresTheBoardAndRefusesAfterAgentEdits(t *testing.T) {
+	m, p := marksModel(t)
+	m = clickAt(t, m, "• Config rewritten", 0)
+	if !strings.Contains(m.notice, "u to undo") {
+		t.Fatalf("notice %q should offer undo", m.notice)
+	}
+	m = press(t, m, "u")
+	if readFile(t, p) != marksBoard || !strings.HasPrefix(m.notice, "undone") {
+		t.Fatalf("undo did not restore the board (notice %q):\n%s", m.notice, readFile(t, p))
+	}
+	m = clickAt(t, m, "• Config rewritten", 0)
+	writeFile(t, p, readFile(t, p)+"- agent added this\n")
+	m = press(t, m, "u")
+	if !strings.Contains(readFile(t, p), "- agent added this") || !strings.Contains(m.notice, "changed since") {
+		t.Fatalf("undo overwrote the agent's edit (notice %q)", m.notice)
+	}
+}
+
+func TestClickingTheStatusMessageUndoes(t *testing.T) {
+	m, p := marksModel(t)
+	m = clickAt(t, m, "• Config rewritten", 0)
+	m.Update(tea.MouseMsg{X: 5, Y: m.vp.Height, Action: tea.MouseActionPress, Button: tea.MouseButtonLeft})
+	if readFile(t, p) != marksBoard {
+		t.Fatal("clicking the status bar should undo the last change")
+	}
+}
+
+func TestUKeyFallsThroughWhenNothingToUndo(t *testing.T) {
+	m, _ := marksModel(t)
+	if m = press(t, m, "u"); m.notice != "" {
+		t.Fatalf("u with nothing to undo should scroll, got notice %q", m.notice)
+	}
+}
+
+const wideBoard = `# Board
+
+## 🧠 Needs you
+
+- PR #30 lets the human answer the agent from the board, with a long line that wraps at every pane width the test tries. It ends mid sentence so nothing hides in slack space.
+  https://github.com/than/sidecar/pull/30
+  Ask: What did you change on your side while this ran, and did the deploy behave?
+  Next: review and merge.
+
+## 🚧 In progress
+
+- Short one.
+- Second short one with **bold** and a [link](https://example.com/a/long/path/that/keeps/going).
+
+## ✅ Done
+
+- shipped
+`
+
+// The bullet and the question must be clickable however the pane wraps.
+func TestControlsWorkAtEveryWidth(t *testing.T) {
+	for w := 24; w <= 200; w += 7 {
+		p := filepath.Join(t.TempDir(), "sidecar.md")
+		writeFile(t, p, wideBoard)
+		m := newModel(p, false)
+		m.mouse = true
+		next, _ := m.Update(tea.WindowSizeMsg{Width: w, Height: 80})
+		m = next.(model)
+
+		if m2 := clickAt(t, m, "• Short one.", 0); !strings.Contains(readFile(t, p), "- [x] Short one.") {
+			t.Fatalf("width %d: bullet click did nothing (notice %q)", w, m2.notice)
+		}
+		writeFile(t, p, wideBoard)
+		m3 := clickAt(t, m, "? What did you change", 2)
+		if !m3.typing {
+			t.Fatalf("width %d: question click did nothing (notice %q)", w, m3.notice)
+		}
+	}
+}
diff --git a/sections.go b/sections.go
index 2270732..6846244 100644
--- a/sections.go
+++ b/sections.go
@@ -160,7 +160,7 @@ func entryStyleRules(sections []Section, bullet string) string {
 		}
 		b.WriteString(" until it needs a decision, and then the `Next:` line asks for that decision.\n")
 	}
-	b.WriteString("\nWhen a turn ends, leave its result as an entry and, under it, an indented `Ask:` line with one narrative question — \"what did you change on your side?\", \"how did the deploy go?\" — never a yes/no. Every open entry shows the human a `[ ✅ Done ]` and a `[ 💬 Reply ]` button; a reply lands under the entry as an `Answer:` line, and `✅ Done` moves it to Done with `Answer: ✅ Done`. Sidecar's hook reports the reply after your next tool call, so read it, act on it, then clear the `Ask:` and `Answer:` lines or move the entry. Choices are optional: `Ask: ✅ Go | ❌ Hold` draws a button for each.\n")
+	b.WriteString("\nWhen a turn ends, leave its result as an entry and, under it, an indented `Ask:` line with one narrative question — \"what did you change on your side?\", \"how did the deploy go?\" — never a yes/no. The human sees it as `? …` and answers under it; the answer arrives as an `Answer:` line, and sidecar's hook reports it after your next tool call, so read it, act on it, then clear the `Ask:` and `Answer:` lines or move the entry. The human can also click any entry's bullet, which turns it to `✓` (`- [x]`): read that as \"I did this\". The human never moves entries between sections — filing them stays yours.\n")
 	return b.String()
 }
 
diff --git a/semdiff.go b/semdiff.go
index b664b89..9849729 100644
--- a/semdiff.go
+++ b/semdiff.go
@@ -363,14 +363,14 @@ func hunkHeader(o, dels, n, adds int) string {
 }
 
 // humanChange names the reader-facing state changes the viewer writes — a
-// ticked box or an answered prompt — so the agent sees the decision in the
-// diff itself, not just that the item changed.
+// ticked bullet or a reply — so the agent sees the decision in the diff
+// itself, not just that the item changed.
 func humanChange(old, new BoardItem) string {
 	var out string
 	switch ot, nt := isTicked(old), isTicked(new); {
-	case isCheckbox(new) && ot != nt && nt:
+	case !ot && nt:
 		out += " — ticked"
-	case isCheckbox(new) && ot != nt:
+	case ot && !nt:
 		out += " — unticked"
 	}
 	if a := answerOf(new); a != answerOf(old) && a != "" {
@@ -379,10 +379,6 @@ func humanChange(old, new BoardItem) string {
 	return out
 }
 
-func isTicked(it BoardItem) bool {
-	return strings.HasPrefix(strings.ToLower(firstLine(it.Raw)), ticked)
-}
-
 func truncateRunes(s string, n int) string {
 	if r := []rune(s); len(r) > n {
 		return string(r[:n]) + "…"
diff --git a/ui.go b/ui.go
index f1f86cd..d6fab61 100644
--- a/ui.go
+++ b/ui.go
@@ -92,12 +92,12 @@ type model struct {
 	mouse            bool
 	typing           bool   // a reply is being typed under the selected item
 	input            string // the reply typed so far
-	hover            hoverChip
+	hover            hoverTarget
 	undo             []undoEntry
 }
 
 func newModel(path string, noFlash bool) model {
-	return model{path: path, noFlash: noFlash, collapsed: map[string]bool{}, cursor: -1, itemSec: -1, itemIdx: -1, hover: hoverChip{line: -1}}
+	return model{path: path, noFlash: noFlash, collapsed: map[string]bool{}, cursor: -1, itemSec: -1, itemIdx: -1, hover: hoverTarget{line: -1}}
 }
 
 func (m model) Init() tea.Cmd {
@@ -381,20 +381,25 @@ func (m *model) reload(force bool) (changed bool) {
 // (applyCursorHighlight) — at the current flash and cursor state.
 func (m *model) compose() string {
 	lines := m.renderedLines
-	// Overlays that swap whole lines work on a copy, before any tint is
-	// layered on: the hovered button turns solid, and a reply being typed
-	// replaces its item's button row.
+	// Overlays that swap or add a line work on a copy, before any tint is
+	// layered on: the hovered bullet or question turns solid, and a reply
+	// being typed is drawn under its item.
 	if m.hover.line >= 0 && m.hover.line < len(lines) {
 		lines = append([]string(nil), lines...)
-		lines[m.hover.line] = strings.Replace(lines[m.hover.line], styleChip(m.hover.chip), hotChip(m.hover.chip), 1)
+		lines[m.hover.line] = paintHover(lines[m.hover.line], m.hover.kind)
 	}
-	if l, text, ok := m.typingRow(m.renderWidth()); ok && l < len(lines) {
-		lines = append([]string(nil), lines...)
-		lines[l] = text
+	if l, text, insert, ok := m.typingRow(m.renderWidth()); ok && l <= len(lines) {
+		copied := append([]string(nil), lines...)
+		if insert {
+			copied = append(copied[:l], append([]string{text}, copied[l:]...)...)
+		} else {
+			copied[l] = text
+		}
+		lines = copied
 	}
 	display := composeMarked(lines, m.changed, m.lineFlash && !m.noFlash, m.renderWidth())
 	display = applyCursorHighlight(display, m.headerLines, m.cursor, m.renderWidth())
-	return applyItemHighlight(display, m.itemStarts, m.itemSec, m.itemIdx, 0, m.renderWidth())
+	return applyItemHighlight(display, m.itemStarts, m.itemSec, m.itemIdx, m.renderWidth())
 }
 
 // recompose re-renders the cached lines for the current flash state without

From 8af41a65b73714c13b0a42d8818a8c158861f4da Mon Sep 17 00:00:00 2001
From: Than Tibbetts <than@broomfitters.com>
Date: Tue, 29 Sep 2026 15:43:55 -0400
Subject: [PATCH 10/11] Indent the question, color every wrapped line, widen
 the tick target, move items with j/k

The question and reply now draw as indented blocks that wrap with a hanging
indent in one color; a click or hover on any of their lines counts. The bullet
target is four cells wide and paints as such under the pointer. j and k move
between items (and scroll a board with none), space ticks, enter replies, and
tab returns to moving between sections.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 README.md                                     |   6 +-
 ...6-09-29-interactive-line-updates-design.md |   6 +-
 edit.go                                       |  11 ++
 interact.go                                   |  66 +++++---
 main.go                                       |   7 +-
 marks.go                                      | 159 ++++++++++++++----
 marks_test.go                                 | 119 ++++++++++++-
 ui.go                                         |  33 ++--
 8 files changed, 320 insertions(+), 87 deletions(-)

diff --git a/README.md b/README.md
index aad225d..440272c 100644
--- a/README.md
+++ b/README.md
@@ -36,9 +36,9 @@ Boards are per-directory. `sidecar init` refuses a board that is a symlink — t
 ## What it does
 
 - Renders Markdown with [glamour] and re-renders the moment the file changes. Sidecar watches the parent directory with fsnotify and a 100-millisecond debounce, so it handles atomic rename-swaps, deletes, and recreates — and waits quietly when the file doesn’t exist yet.
-- Scrolls with `j` and `k`, the arrow keys, `PgUp` and `PgDn`, and `g` and `G` for top and bottom, or with the mouse wheel. Sidecar keeps your scroll position across reloads.
-- Talks back to the agent. The bullet is the control: click a `•` and it becomes `✓` (the file gets `- [x]`), click again to undo. When the agent asks a question — an indented `Ask:` line, drawn as `? …` — click it, or press `a`, and type your answer under the item; Enter writes it as an `Answer:` line, and `sidecar`'s hook hands it to the agent after its next tool call, no chat message needed. Nothing you do moves an item between sections; that stays the agent's job. `u`, or a click on the status-bar message, undoes the last change and refuses if the agent has edited the board since.
-- Clicks work by default: bullets, questions, section headers, and the wheel. Whatever is clickable turns solid under the pointer. Mouse capture costs the terminal's plain drag-to-select — hold Shift (Option in iTerm2) to select anyway, press `M` to switch capture off and on, or start with `--no-mouse`. Everything also has a key: `]` and `[` select an item, `x` ticks it, `a` replies, `}` and `{` jump between open questions, and `esc` deselects. The status bar counts the questions still waiting on you.
+- Scrolls with the arrow keys, `PgUp` and `PgDn`, and `g` and `G` for top and bottom, or with the mouse wheel (`j` and `k` move between items; they scroll a board that has none). Sidecar keeps your scroll position across reloads.
+- Talks back to the agent. The bullet is the control: click a `•` and it becomes `✓` (the file gets `- [x]`), click again to undo. When the agent asks a question — an indented `Ask:` line, drawn as an indented `? …` block — click it, or press `enter`, and type your answer under the item; Enter writes it as an `Answer:` line, and `sidecar`'s hook hands it to the agent after its next tool call, no chat message needed. Nothing you do moves an item between sections; that stays the agent's job. `u`, or a click on the status-bar message, undoes the last change and refuses if the agent has edited the board since.
+- Clicks work by default: bullets, questions, section headers, and the wheel. Whatever is clickable turns solid under the pointer. Mouse capture costs the terminal's plain drag-to-select — hold Shift (Option in iTerm2) to select anyway, press `M` to switch capture off and on, or start with `--no-mouse`. Everything also has a key: `j` and `k` move between items (the wheel and arrow keys scroll), `space` ticks the selected item, `enter` replies, `}` and `{` jump between open questions, and `esc` deselects. `tab` still moves between sections. The status bar counts the questions still waiting on you.
 - `Tab` and `Shift+Tab` move a cursor between sections; `Enter` or `Space` collapses or expands the section under it. `✅ Done` and `📦 Shipped` start collapsed — every heading shows its item count, e.g. `✅ Done (12)`.
 - Reloads on demand with `r`, and quits with `q`.
 - Re-renders when you resize the terminal, at the pane width minus 2. It never renders wider than the pane.
diff --git a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
index 08f1a24..e7f3908 100644
--- a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
+++ b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
@@ -11,8 +11,8 @@ The viewer is the human's channel back to the agent. The agent owns the board an
 
 ## What the human sees and does
 
-- **The bullet is the control.** Click `•` and it turns into `✓`; the file gets `- [x]`. Click again and it is a plain bullet. `x` does the same on the selected item.
-- **`? question`** — an `Ask:` line is drawn as `? …` in the accent color. Click it, or press `a` on the item, and a reply line opens under the item; Enter writes it, esc abandons it. The reply shows as `↳ …`. The reply line is pre-filled with the current reply so it can be edited, and shows `type your reply… ⏎ send · esc cancel` when empty.
+- **The bullet is the control.** Click within the first four columns of an item's first line and `•` turns into `✓`; the file gets `- [x]`. Click again and it is a plain bullet. `space` does the same on the selected item.
+- **`? question`** — an `Ask:` line is drawn as an indented `? …` block in one accent color, wrapped with a hanging indent. Click any line of it, or press `enter` on the item, and a reply line opens under the item; Enter writes it, esc abandons it. The reply shows as `↳ …`. The reply line is pre-filled with the current reply so it can be edited, and shows `type your reply… ⏎ send · esc cancel` when empty.
 - Whatever is clickable — bullet or question — turns solid under the pointer; nothing else changes on hover.
 - One blank line separates items.
 - The viewer never moves an item between sections. Filing stays with the agent.
@@ -40,7 +40,7 @@ Plain markdown; the file never contains a control.
 
 ## Keyboard
 
-`]` / `[` select an item, `x` ticks, `a` replies, `}` / `{` jump between unanswered questions, `u` undoes, `esc` deselects. The status bar counts open questions.
+`j` / `k` move between items (they scroll when the board has none; arrows and the wheel always scroll), `space` ticks, `enter` replies, `}` / `{` jump between unanswered questions, `u` undoes, `esc` deselects, `tab` moves between sections. The status bar counts open questions.
 
 ## Known limits
 
diff --git a/edit.go b/edit.go
index 27ba929..4c4da4c 100644
--- a/edit.go
+++ b/edit.go
@@ -61,6 +61,17 @@ func hasAsk(it BoardItem) bool {
 	return false
 }
 
+// askText is the question on the item's "Ask:" line, "" when it has none.
+func askText(it BoardItem) string {
+	_, rest, _ := strings.Cut(it.Raw, "\n")
+	for _, ln := range strings.Split(rest, "\n") {
+		if v, ok := strings.CutPrefix(strings.TrimSpace(ln), "Ask:"); ok {
+			return strings.TrimSpace(v)
+		}
+	}
+	return ""
+}
+
 // isUnanswered reports a question still waiting on the human.
 func isUnanswered(it BoardItem) bool { return hasAsk(it) && answerOf(it) == "" }
 
diff --git a/interact.go b/interact.go
index c4aaf23..0555bd4 100644
--- a/interact.go
+++ b/interact.go
@@ -95,10 +95,10 @@ func (m *model) selectItem(si, ii int) {
 }
 
 // moveItemCursor steps to the next (+1) or previous (-1) item, wrapping.
-func (m *model) moveItemCursor(delta int) {
+func (m *model) moveItemCursor(delta int) bool {
 	all, cur := m.itemPositions()
 	if len(all) == 0 {
-		return
+		return false
 	}
 	next := 0
 	switch {
@@ -108,6 +108,7 @@ func (m *model) moveItemCursor(delta int) {
 		next = len(all) - 1
 	}
 	m.selectItem(all[next][0], all[next][1])
+	return true
 }
 
 // moveQuestionCursor selects the next (+1) or previous (-1) unanswered
@@ -160,9 +161,9 @@ func (m *model) itemKey(key string) bool {
 	switch key {
 	case "esc":
 		m.clearItemCursor()
-	case "x":
+	case "x", " ":
 		m.tick(label, it)
-	case "a":
+	case "a", "enter":
 		m.startReply(it)
 	default:
 		return false
@@ -289,7 +290,7 @@ func (m model) hint() string {
 	if answerOf(it) != "" {
 		reply = "a edit reply"
 	}
-	return strings.Join([]string{"[ prev · ] next", tick, reply, "esc"}, " · ")
+	return strings.Join([]string{"j k move", "space " + strings.TrimPrefix(tick, "x "), "enter " + strings.TrimPrefix(reply, "a "), "esc"}, " · ")
 }
 
 // itemAtLine finds the mapped, real item whose rendered lines include line.
@@ -308,19 +309,24 @@ func (m model) itemAtLine(line int) (si, ii, start int, ok bool) {
 }
 
 // targetAt classifies what is under a click or the pointer: the bullet (the
-// first two columns of an item's first line) or the item's question line.
-func (m model) targetAt(x, line int) (si, ii int, kind hoverKind) {
+// first few columns of an item's first line) or any line of the item's
+// question. last is the question's final line.
+func (m model) targetAt(x, line int) (si, ii, last int, kind hoverKind) {
 	si, ii, start, ok := m.itemAtLine(line)
 	if !ok {
-		return 0, 0, hoverNone
+		return 0, 0, 0, hoverNone
 	}
-	switch {
-	case line == start && x <= 1:
-		return si, ii, hoverBullet
-	case isQuestionLine(m.renderedLines[line]):
-		return si, ii, hoverQuestion
+	if line == start && x < bulletCells {
+		return si, ii, line, hoverBullet
 	}
-	return si, ii, hoverNone
+	it := m.board.Sections[si].Items[ii]
+	if q := plainMark(askText(it)); q != "" {
+		end := itemEnd(m.renderedLines, m.itemStarts[si], ii)
+		if f, l, ok := markBlock(m.renderedLines, start+1, end, questionPrefix, q); ok && line >= f && line <= l {
+			return si, ii, l, hoverQuestion
+		}
+	}
+	return si, ii, line, hoverNone
 }
 
 // mouseClick acts on a left click: a section header collapses, a bullet
@@ -343,7 +349,7 @@ func (m *model) mouseClick(x, y int) {
 			return
 		}
 	}
-	si, ii, kind := m.targetAt(x, line)
+	si, ii, _, kind := m.targetAt(x, line)
 	if _, _, _, ok := m.itemAtLine(line); !ok {
 		m.notice = fmt.Sprintf("click %d,%d — nothing to click on that line", x, y)
 		return
@@ -366,8 +372,13 @@ func (m *model) setHover(x, y int) {
 	next := hoverTarget{line: -1}
 	if y >= 0 && y < m.vp.Height {
 		line := y + m.vp.YOffset
-		if _, _, kind := m.targetAt(x, line); kind != hoverNone {
-			next = hoverTarget{line: line, kind: kind}
+		if si, ii, last, kind := m.targetAt(x, line); kind != hoverNone {
+			first := line
+			if kind == hoverQuestion {
+				start := m.itemStarts[si][ii]
+				first, _, _ = markBlock(m.renderedLines, start+1, itemEnd(m.renderedLines, m.itemStarts[si], ii), questionPrefix, plainMark(askText(m.board.Sections[si].Items[ii])))
+			}
+			next = hoverTarget{line: first, last: last, kind: kind}
 		}
 	}
 	if next != m.hover {
@@ -376,12 +387,12 @@ func (m *model) setHover(x, y int) {
 	}
 }
 
-// typingRow finds where the reply being typed is drawn: on the item's reply
-// line when it has one, otherwise as a new line after its last line. insert
-// says which.
-func (m model) typingRow(width int) (line int, text string, insert, ok bool) {
+// typingRow finds where the reply being typed is drawn: over the item's
+// reply block when it has one (first through last), otherwise as a new line
+// after its last line (insert). text is the styled row.
+func (m model) typingRow(width int) (first, last int, text string, insert, ok bool) {
 	if !m.typing || m.itemSec < 0 || m.itemSec >= len(m.itemStarts) || m.itemIdx >= len(m.itemStarts[m.itemSec]) {
-		return 0, "", false, false
+		return 0, 0, "", false, false
 	}
 	ss := m.itemStarts[m.itemSec]
 	end := itemEnd(m.renderedLines, ss, m.itemIdx)
@@ -398,16 +409,17 @@ func (m model) typingRow(width int) (line int, text string, insert, ok bool) {
 	for visibleWidth(shown) > room && shown != "" {
 		shown = string([]rune(shown)[1:])
 	}
-	row := typingStyle.Render(" " + replyPrefix + shown + "▌ ")
+	row := "  " + typingStyle.Render(" "+replyPrefix+shown+"▌ ")
 	if showHint {
 		row += "  " + hintStyle.Render(hint)
 	}
-	for l := ss[m.itemIdx] + 1; l < end; l++ {
-		if strings.HasPrefix(strings.TrimRight(stripANSI(m.renderedLines[l]), " "), replyPrefix) {
-			return l, row, false, true
+	it := m.board.Sections[m.itemSec].Items[m.itemIdx]
+	if r := plainMark(answerOf(it)); r != "" {
+		if f, l, found := markBlock(m.renderedLines, ss[m.itemIdx]+1, end, replyPrefix, r); found {
+			return f, l, row, false, true
 		}
 	}
-	return end, row, true, true
+	return end, end, row, true, true
 }
 
 func (m *model) toggleMouse() tea.Cmd {
diff --git a/main.go b/main.go
index ba014f8..4410b5d 100644
--- a/main.go
+++ b/main.go
@@ -31,12 +31,13 @@ usage: sidecar [file.md]         (default: .sidecar/sidecar.md)
        sidecar --no-flash [file] disable the subtle change-flash (▸ still shows)
        sidecar --no-mouse [file] start without mouse capture (native text selection)
 
-keys:  j/k, arrows, PgUp/PgDn, wheel        scroll
+keys:  arrows, PgUp/PgDn, wheel             scroll
+       j / k                                move between items (scrolls when there are none)
        g / G                                top / bottom
        tab / shift+tab                      move between sections
        enter / space                        collapse / expand section
-       click a • bullet, or  ] / [ then x   tick it ✓ (again to untick)
-       click a ? question, or  a            answer the agent, in your own words
+       click a • bullet, or  space          tick it ✓ (again to untick)
+       click a ? question, or  enter        answer the agent, in your own words
        } / {                                next / previous open question
        u                                    undo the last change made from the viewer
        esc                                  deselect
diff --git a/marks.go b/marks.go
index c12451a..c29c0d5 100644
--- a/marks.go
+++ b/marks.go
@@ -13,9 +13,11 @@
 package main
 
 import (
+	"sort"
 	"strings"
 
 	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/x/ansi"
 )
 
 var (
@@ -60,9 +62,9 @@ func displayText(raw string, board Board, collapsed map[string]bool) string {
 				indent := lines[i][:len(lines[i])-len(strings.TrimLeft(lines[i], " \t"))]
 				switch {
 				case strings.HasPrefix(t, "Ask:"):
-					lines[i] = indent + questionPrefix + strings.TrimSpace(strings.TrimPrefix(t, "Ask:"))
+					lines[i] = indent + questionPrefix + plainMark(strings.TrimSpace(strings.TrimPrefix(t, "Ask:")))
 				case strings.HasPrefix(t, "Answer:"):
-					lines[i] = indent + replyPrefix + strings.TrimSpace(strings.TrimPrefix(t, "Answer:"))
+					lines[i] = indent + replyPrefix + plainMark(strings.TrimSpace(strings.TrimPrefix(t, "Answer:")))
 				}
 			}
 		}
@@ -83,28 +85,116 @@ func renderBoardLines(display string, board Board, width int) ([]string, error)
 		return lines, nil
 	}
 	starts := itemStartLines(lines, sectionHeaderLines(lines), board)
-	return spaceItems(colorMarks(lines, starts), starts), nil
+	lines = rewriteMarks(lines, starts, board, width)
+	starts = itemStartLines(lines, sectionHeaderLines(lines), board) // the reflow can change line counts
+	return spaceItems(lines, starts), nil
 }
 
-// colorMarks paints each question in the accent color and each reply green.
-// Only lines inside a mapped item are touched, so body text that happens to
-// begin "? " elsewhere is left alone.
-func colorMarks(lines []string, starts [][]int) []string {
-	out := append([]string(nil), lines...)
-	for _, ss := range starts {
+// plainMark is question or reply text as glamour will show it: the markdown
+// emphasis and code marks are dropped, so the words can be found again in the
+// rendered lines.
+func plainMark(s string) string { return strings.NewReplacer("`", "", "*", "").Replace(s) }
+
+// markBlock finds the rendered lines of a question or reply inside an item's
+// lines [from, to): the line that begins with prefix, plus the lines glamour
+// wrapped it onto — followed by matching the words of text one by one. ok is
+// false when no line begins with prefix.
+func markBlock(lines []string, from, to int, prefix, text string) (first, last int, ok bool) {
+	words := strings.Fields(text)
+	for l := from; l < to && l < len(lines); l++ {
+		t := strings.TrimLeft(strings.TrimRight(stripANSI(lines[l]), " "), " ")
+		if !strings.HasPrefix(t, prefix) {
+			continue
+		}
+		got := strings.Fields(strings.TrimPrefix(t, prefix))
+		last = l
+		for last+1 < to && last+1 < len(lines) && len(got) < len(words) {
+			more := strings.Fields(stripANSI(lines[last+1]))
+			if len(more) == 0 || len(got)+len(more) > len(words) || !equalWords(words[len(got):len(got)+len(more)], more) {
+				break
+			}
+			got = append(got, more...)
+			last++
+		}
+		return l, last, true
+	}
+	return 0, 0, false
+}
+
+func equalWords(a, b []string) bool {
+	for i := range b {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// reflow lays "prefix text" out under an item: indented two, wrapped to width,
+// continuation lines hanging under the text, every line in style.
+func reflow(prefix, text string, width int, style lipgloss.Style) []string {
+	const indent = "  "
+	hang := strings.Repeat(" ", len(indent)+visibleWidth(prefix))
+	cur, curW, fresh := indent+prefix, len(indent)+visibleWidth(prefix), true
+	var rows []string
+	for _, w := range strings.Fields(text) {
+		ww := visibleWidth(w)
+		if !fresh && curW+1+ww > width {
+			rows = append(rows, style.Render(cur))
+			cur, curW, fresh = hang, len(hang), true
+		}
+		if !fresh {
+			cur += " "
+			curW++
+		}
+		cur += w
+		curW += ww
+		fresh = false
+	}
+	return append(rows, style.Render(cur))
+}
+
+// rewriteMarks redraws each mapped item's question and reply as an indented,
+// wrapped block in one color — glamour wraps them at column 0 and leaves the
+// wrapped lines uncolored.
+func rewriteMarks(lines []string, starts [][]int, board Board, width int) []string {
+	type swap struct {
+		first, last int
+		rows        []string
+	}
+	var swaps []swap
+	for si, ss := range starts {
 		for ii, start := range ss {
+			it := board.Sections[si].Items[ii]
 			end := itemEnd(lines, ss, ii)
-			for l := start + 1; l < end && l < len(out); l++ {
-				t := strings.TrimRight(stripANSI(out[l]), " ")
-				switch {
-				case strings.HasPrefix(t, questionPrefix):
-					out[l] = questionStyle.Render(t)
-				case strings.HasPrefix(t, replyPrefix):
-					out[l] = replyLineStyle.Render(t)
+			for _, mk := range []struct {
+				prefix, text string
+				style        lipgloss.Style
+			}{
+				{questionPrefix, plainMark(askText(it)), questionStyle},
+				{replyPrefix, plainMark(answerOf(it)), replyLineStyle},
+			} {
+				if mk.text == "" {
+					continue
+				}
+				if f, l, ok := markBlock(lines, start+1, end, mk.prefix, mk.text); ok {
+					swaps = append(swaps, swap{f, l, reflow(mk.prefix, mk.text, width, mk.style)})
 				}
 			}
 		}
 	}
+	sort.Slice(swaps, func(i, j int) bool { return swaps[i].first < swaps[j].first })
+	var out []string
+	next := 0
+	for i := 0; i < len(lines); i++ {
+		if next < len(swaps) && i == swaps[next].first {
+			out = append(out, swaps[next].rows...)
+			i = swaps[next].last
+			next++
+			continue
+		}
+		out = append(out, lines[i])
+	}
 	return out
 }
 
@@ -157,30 +247,33 @@ const (
 	hoverQuestion
 )
 
-// hoverTarget is the clickable thing under the pointer: which rendered line
-// and what it is.
+// hoverTarget is the clickable thing under the pointer: the rendered lines
+// it covers (line through last) and what it is.
 type hoverTarget struct {
-	line int
-	kind hoverKind
+	line, last int
+	kind       hoverKind
 }
 
-// isQuestionLine reports a rendered line that is an item's question.
+// bulletCells is how many columns from the left edge tick an item — the
+// bullet, its space, and a little slack, so the target is easy to hit.
+const bulletCells = 4
+
+// isQuestionLine reports a rendered line that starts a question.
 func isQuestionLine(rendered string) bool {
-	return strings.HasPrefix(strings.TrimRight(stripANSI(rendered), " "), questionPrefix)
+	return strings.HasPrefix(strings.TrimLeft(strings.TrimRight(stripANSI(rendered), " "), " "), questionPrefix)
 }
 
-// paintHover repaints the hovered bullet or question on a copy-safe line: the
-// bullet glyph turns solid, the question goes bold and underlined.
-func paintHover(line string, kind hoverKind) string {
-	switch kind {
+// paintHover repaints what the pointer is over, on lines the caller has
+// already copied: the leading cells of a bullet turn solid, and every line of
+// a question goes bold and underlined.
+func paintHover(lines []string, h hoverTarget) {
+	switch h.kind {
 	case hoverBullet:
-		for _, g := range []string{"•", "✓", "□"} {
-			if strings.Contains(line, g) {
-				return strings.Replace(line, g, bulletHotStyle.Render(g), 1)
-			}
-		}
+		l := lines[h.line]
+		lines[h.line] = bulletHotStyle.Render(stripANSI(ansi.Cut(l, 0, bulletCells))) + ansi.Cut(l, bulletCells, visibleWidth(l))
 	case hoverQuestion:
-		return questionHotStyle.Render(strings.TrimRight(stripANSI(line), " "))
+		for i := h.line; i <= h.last && i < len(lines); i++ {
+			lines[i] = questionHotStyle.Render(strings.TrimRight(stripANSI(lines[i]), " "))
+		}
 	}
-	return line
 }
diff --git a/marks_test.go b/marks_test.go
index d863f5b..b4d3c31 100644
--- a/marks_test.go
+++ b/marks_test.go
@@ -161,7 +161,7 @@ func TestReplyOnItemWithoutQuestionIsInsertedAfterIt(t *testing.T) {
 		rows = append(rows, strings.TrimRight(l, " "))
 	}
 	v := strings.Join(rows, "\n")
-	if !strings.Contains(v, "• Second item.\n ↳ unprompted note▌") {
+	if !strings.Contains(v, "• Second item.\n   ↳ unprompted note▌") {
 		t.Fatalf("typed line should appear under the item:\n%s", v)
 	}
 	special(t, m, tea.KeyEnter)
@@ -208,11 +208,11 @@ func TestHoverPaintsBulletAndQuestion(t *testing.T) {
 	rest := m.vp.View()
 
 	m = mouseAt(t, m, "• Config rewritten", 0, tea.MouseActionMotion, tea.MouseButtonNone)
-	if m.hover.kind != hoverBullet || m.vp.View() == rest || !strings.Contains(m.vp.View(), bulletHotStyle.Render("•")) {
+	if m.hover.kind != hoverBullet || m.vp.View() == rest || !strings.Contains(m.vp.View(), bulletHotStyle.Render("• Co")) {
 		t.Fatalf("hovering the bullet should paint it solid (hover %+v)", m.hover)
 	}
 	m = mouseAt(t, m, "? What did you change", 4, tea.MouseActionMotion, tea.MouseButtonNone)
-	if m.hover.kind != hoverQuestion || !strings.Contains(m.vp.View(), "\x1b[4") && !strings.Contains(m.vp.View(), ";4;") && !strings.Contains(m.vp.View(), "[1;4") {
+	if m.hover.kind != hoverQuestion || !strings.Contains(m.vp.View(), questionHotStyle.Render("  ? What did you change on your side in the meantime?")) {
 		t.Fatalf("hovering the question should underline it (hover %+v)", m.hover)
 	}
 	m = mouseAt(t, m, "Next: reply", 0, tea.MouseActionMotion, tea.MouseButtonNone)
@@ -297,9 +297,120 @@ func TestControlsWorkAtEveryWidth(t *testing.T) {
 			t.Fatalf("width %d: bullet click did nothing (notice %q)", w, m2.notice)
 		}
 		writeFile(t, p, wideBoard)
-		m3 := clickAt(t, m, "? What did you change", 2)
+		m3 := clickAt(t, m, "? What", 2)
 		if !m3.typing {
 			t.Fatalf("width %d: question click did nothing (notice %q)", w, m3.notice)
 		}
 	}
 }
+
+const longQuestionBoard = `# Board
+
+## 🧠 Needs you
+
+- Result of the turn.
+  Ask: After relaunching, does ticking a bullet and answering a question feel right, or is something still missing from the flow?
+  Next: review.
+`
+
+func TestQuestionIsIndentedAndOneColorOnEveryWrappedLine(t *testing.T) {
+	prev := lipgloss.ColorProfile()
+	lipgloss.SetColorProfile(termenv.TrueColor)
+	t.Cleanup(func() { lipgloss.SetColorProfile(prev) })
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, longQuestionBoard)
+	m := testModel(t, p) // 60 wide: the question wraps
+	var block []string
+	for _, ln := range m.renderedLines {
+		plain := stripANSI(ln)
+		if strings.HasPrefix(plain, "  ? ") || (len(block) > 0 && strings.HasPrefix(plain, "    ") && strings.TrimSpace(plain) != "") {
+			if !strings.HasPrefix(ln, "\x1b") || !strings.Contains(ln, "229;192;123") {
+				t.Fatalf("question line lost its color: %q", ln)
+			}
+			block = append(block, plain)
+		}
+	}
+	if len(block) < 2 {
+		t.Fatalf("expected the question to wrap over several lines, got %q", block)
+	}
+	for _, l := range block[1:] {
+		if !strings.HasPrefix(l, "    ") {
+			t.Fatalf("wrapped lines should hang under the text: %q", l)
+		}
+	}
+	if !strings.Contains(strings.Join(strings.Fields(strings.Join(block, " ")), " "), "still missing from the flow?") {
+		t.Fatalf("question text lost: %q", block)
+	}
+}
+
+func TestClickOnAWrappedQuestionLineOpensReply(t *testing.T) {
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, longQuestionBoard)
+	m := testModel(t, p)
+	m.mouse = true
+	m = clickAt(t, m, "still missing", 1) // the last wrapped line
+	if !m.typing {
+		t.Fatalf("any line of the question should open the reply (notice %q)", m.notice)
+	}
+}
+
+func TestBulletTargetIsFourCellsWide(t *testing.T) {
+	for _, x := range []int{0, 1, 2, 3} {
+		m, p := marksModel(t)
+		clickAt(t, m, "• Config rewritten", x)
+		if !strings.Contains(readFile(t, p), "[x] Config") {
+			t.Fatalf("a click %d cells in should tick", x)
+		}
+	}
+	m, p := marksModel(t)
+	clickAt(t, m, "• Config rewritten", 4)
+	if readFile(t, p) != marksBoard {
+		t.Fatal("a click past the target must not tick")
+	}
+}
+
+func TestJKMoveBetweenItemsAndScrollWhenThereAreNone(t *testing.T) {
+	m, _ := marksModel(t)
+	m = press(t, m, "j")
+	if it, _, ok := m.selected(); !ok || !strings.HasPrefix(it.Key, "Config rewritten") {
+		t.Fatalf("j should select the first item, got %+v", it)
+	}
+	m = press(t, m, "j")
+	if it, _, _ := m.selected(); it.Key != "Second item." {
+		t.Fatalf("j should move down, got %q", it.Key)
+	}
+	m = press(t, m, "k")
+	if it, _, _ := m.selected(); !strings.HasPrefix(it.Key, "Config rewritten") {
+		t.Fatalf("k should move up, got %q", it.Key)
+	}
+	// No items at all: j is plain scrolling.
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, manyLines(100, "x"))
+	s := testModel(t, p)
+	before := s.vp.YOffset
+	s = press(t, s, "j")
+	if s.vp.YOffset != before+1 {
+		t.Fatalf("with nothing to select j should scroll (offset %d → %d)", before, s.vp.YOffset)
+	}
+}
+
+func TestSpaceTicksAndEnterReplies(t *testing.T) {
+	m, p := marksModel(t)
+	m = press(t, m, "j", " ")
+	if !strings.Contains(readFile(t, p), "- [x] Config rewritten") {
+		t.Fatalf("space should tick the selected item:\n%s", readFile(t, p))
+	}
+	m = special(t, m, tea.KeyEnter)
+	if !m.typing {
+		t.Fatal("enter should open the reply")
+	}
+}
+
+func TestTabLeavesItemSelectionForSections(t *testing.T) {
+	m, _ := marksModel(t)
+	m = press(t, m, "j")
+	m = special(t, m, tea.KeyTab)
+	if m.itemSec != -1 {
+		t.Fatal("tab moves between sections and drops the item selection")
+	}
+}
diff --git a/ui.go b/ui.go
index d6fab61..e2d17e9 100644
--- a/ui.go
+++ b/ui.go
@@ -133,12 +133,14 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		switch msg.String() {
 		case "q", "ctrl+c":
 			return m, tea.Quit
-		case "]":
-			m.moveItemCursor(1)
-			return m, nil
-		case "[":
-			m.moveItemCursor(-1)
-			return m, nil
+		case "j", "]":
+			if m.moveItemCursor(1) {
+				return m, nil
+			}
+		case "k", "[":
+			if m.moveItemCursor(-1) {
+				return m, nil
+			}
 		case "}":
 			m.moveQuestionCursor(1)
 			return m, nil
@@ -175,9 +177,11 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.vp.GotoBottom()
 			return m, nil
 		case "tab":
+			m.itemSec, m.itemIdx = -1, -1 // Tab moves between sections, not items
 			m.moveCursor(1)
 			return m, nil
 		case "shift+tab":
+			m.itemSec, m.itemIdx = -1, -1
 			m.moveCursor(-1)
 			return m, nil
 		case "enter", " ":
@@ -384,18 +388,19 @@ func (m *model) compose() string {
 	// Overlays that swap or add a line work on a copy, before any tint is
 	// layered on: the hovered bullet or question turns solid, and a reply
 	// being typed is drawn under its item.
-	if m.hover.line >= 0 && m.hover.line < len(lines) {
+	if m.hover.line >= 0 && m.hover.last < len(lines) {
 		lines = append([]string(nil), lines...)
-		lines[m.hover.line] = paintHover(lines[m.hover.line], m.hover.kind)
+		paintHover(lines, m.hover)
 	}
-	if l, text, insert, ok := m.typingRow(m.renderWidth()); ok && l <= len(lines) {
-		copied := append([]string(nil), lines...)
-		if insert {
-			copied = append(copied[:l], append([]string{text}, copied[l:]...)...)
+	if f, l, text, insert, ok := m.typingRow(m.renderWidth()); ok && l <= len(lines) {
+		copied := append([]string(nil), lines[:f]...)
+		copied = append(copied, text)
+		if !insert {
+			l++
 		} else {
-			copied[l] = text
+			l = f
 		}
-		lines = copied
+		lines = append(copied, lines[l:]...)
 	}
 	display := composeMarked(lines, m.changed, m.lineFlash && !m.noFlash, m.renderWidth())
 	display = applyCursorHighlight(display, m.headerLines, m.cursor, m.renderWidth())

From 39295a7140d7bdc454bd432e6e4c55a48494dc17 Mon Sep 17 00:00:00 2001
From: Than Tibbetts <than@broomfitters.com>
Date: Tue, 29 Sep 2026 17:12:13 -0400
Subject: [PATCH 11/11] Open links from the viewer, since mouse capture stops
 the terminal doing it

The viewer finds the OSC 8 link under the pointer in the rendered line, paints
it on hover, shows its full address in the status bar, and opens it on a click.
Only http, https, and mailto open. Clicks are held while a reply is being typed.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 README.md                                     |   2 +-
 ...6-09-29-interactive-line-updates-design.md |   5 +-
 interact.go                                   |  21 ++-
 links.go                                      | 133 ++++++++++++++++
 links_test.go                                 | 144 ++++++++++++++++++
 marks.go                                      |   4 +
 ui.go                                         |   2 +
 7 files changed, 306 insertions(+), 5 deletions(-)
 create mode 100644 links.go
 create mode 100644 links_test.go

diff --git a/README.md b/README.md
index 440272c..98f1f88 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@ Boards are per-directory. `sidecar init` refuses a board that is a symlink — t
 - Renders Markdown with [glamour] and re-renders the moment the file changes. Sidecar watches the parent directory with fsnotify and a 100-millisecond debounce, so it handles atomic rename-swaps, deletes, and recreates — and waits quietly when the file doesn’t exist yet.
 - Scrolls with the arrow keys, `PgUp` and `PgDn`, and `g` and `G` for top and bottom, or with the mouse wheel (`j` and `k` move between items; they scroll a board that has none). Sidecar keeps your scroll position across reloads.
 - Talks back to the agent. The bullet is the control: click a `•` and it becomes `✓` (the file gets `- [x]`), click again to undo. When the agent asks a question — an indented `Ask:` line, drawn as an indented `? …` block — click it, or press `enter`, and type your answer under the item; Enter writes it as an `Answer:` line, and `sidecar`'s hook hands it to the agent after its next tool call, no chat message needed. Nothing you do moves an item between sections; that stays the agent's job. `u`, or a click on the status-bar message, undoes the last change and refuses if the agent has edited the board since.
-- Clicks work by default: bullets, questions, section headers, and the wheel. Whatever is clickable turns solid under the pointer. Mouse capture costs the terminal's plain drag-to-select — hold Shift (Option in iTerm2) to select anyway, press `M` to switch capture off and on, or start with `--no-mouse`. Everything also has a key: `j` and `k` move between items (the wheel and arrow keys scroll), `space` ticks the selected item, `enter` replies, `}` and `{` jump between open questions, and `esc` deselects. `tab` still moves between sections. The status bar counts the questions still waiting on you.
+- Clicks work by default: bullets, questions, section headers, links, and the wheel. Whatever is clickable turns solid under the pointer, and a link shows its full address in the status bar. Because capture stops the terminal from opening links itself, the viewer opens them — web and mail links only. Mouse capture costs the terminal's plain drag-to-select — hold Shift (Option in iTerm2) to select anyway, press `M` to switch capture off and on, or start with `--no-mouse`. Everything also has a key: `j` and `k` move between items (the wheel and arrow keys scroll), `space` ticks the selected item, `enter` replies, `}` and `{` jump between open questions, and `esc` deselects. `tab` still moves between sections. The status bar counts the questions still waiting on you.
 - `Tab` and `Shift+Tab` move a cursor between sections; `Enter` or `Space` collapses or expands the section under it. `✅ Done` and `📦 Shipped` start collapsed — every heading shows its item count, e.g. `✅ Done (12)`.
 - Reloads on demand with `r`, and quits with `q`.
 - Re-renders when you resize the terminal, at the pane width minus 2. It never renders wider than the pane.
diff --git a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
index e7f3908..685e89e 100644
--- a/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
+++ b/docs/superpowers/specs/2026-09-29-interactive-line-updates-design.md
@@ -13,7 +13,8 @@ The viewer is the human's channel back to the agent. The agent owns the board an
 
 - **The bullet is the control.** Click within the first four columns of an item's first line and `•` turns into `✓`; the file gets `- [x]`. Click again and it is a plain bullet. `space` does the same on the selected item.
 - **`? question`** — an `Ask:` line is drawn as an indented `? …` block in one accent color, wrapped with a hanging indent. Click any line of it, or press `enter` on the item, and a reply line opens under the item; Enter writes it, esc abandons it. The reply shows as `↳ …`. The reply line is pre-filled with the current reply so it can be edited, and shows `type your reply… ⏎ send · esc cancel` when empty.
-- Whatever is clickable — bullet or question — turns solid under the pointer; nothing else changes on hover.
+- **Links** open on a click. Capture stops the terminal handling OSC 8 links, so the viewer finds the link under the pointer in the rendered line and opens it (web and mail schemes only; never `file:` or an app's scheme). The full address shows in the status bar on hover.
+- Whatever is clickable — bullet, question, or link — turns solid under the pointer; nothing else changes on hover.
 - One blank line separates items.
 - The viewer never moves an item between sections. Filing stays with the agent.
 
@@ -46,4 +47,4 @@ Plain markdown; the file never contains a control.
 
 - Items are mapped to rendered lines by their column-0 marker (`•`, `□`, `✓`); a section whose rendered count differs from the parsed count (collapsed) is skipped rather than mis-selected.
 - When `--mid-turn` reports, the snapshot advances whole, so an agent edit made in the same window is not repeated in the next prompt's diff.
-- Clicking a link while capture is on may not reach the terminal's own link handling; the viewer does not open links itself yet.
+- A click is held while a reply is being typed, so it cannot act on a line the typing row has shifted.
diff --git a/interact.go b/interact.go
index 0555bd4..b69af96 100644
--- a/interact.go
+++ b/interact.go
@@ -341,7 +341,17 @@ func (m *model) mouseClick(x, y int) {
 		m.notice = fmt.Sprintf("click %d,%d — the status bar is not clickable", x, y)
 		return
 	}
+	if m.typing {
+		m.notice = "finish the reply first — enter sends, esc cancels"
+		return
+	}
 	line := y + m.vp.YOffset
+	if line < len(m.renderedLines) {
+		if s, ok := linkAt(m.renderedLines[line], x); ok {
+			m.openLink(s.url)
+			return
+		}
+	}
 	for si, h := range m.headerLines {
 		if h == line {
 			m.cursor = si
@@ -370,9 +380,16 @@ func (m *model) mouseClick(x, y int) {
 // re-renders only when the target changes.
 func (m *model) setHover(x, y int) {
 	next := hoverTarget{line: -1}
-	if y >= 0 && y < m.vp.Height {
+	if y >= 0 && y < m.vp.Height && !m.typing {
 		line := y + m.vp.YOffset
-		if si, ii, last, kind := m.targetAt(x, line); kind != hoverNone {
+		if line < len(m.renderedLines) {
+			if s, ok := linkAt(m.renderedLines[line], x); ok {
+				next = hoverTarget{line: line, last: line, kind: hoverLink, link: s}
+			}
+		}
+		if next.line >= 0 {
+			// a link wins over the item it sits in
+		} else if si, ii, last, kind := m.targetAt(x, line); kind != hoverNone {
 			first := line
 			if kind == hoverQuestion {
 				start := m.itemStarts[si][ii]
diff --git a/links.go b/links.go
new file mode 100644
index 0000000..964d99a
--- /dev/null
+++ b/links.go
@@ -0,0 +1,133 @@
+// links.go — clickable links. With mouse capture on, the terminal no longer
+// handles a click on an OSC 8 hyperlink, so the viewer does: it finds the
+// link under the pointer in the rendered line, paints it on hover, shows the
+// full address in the status bar, and opens it on a click.
+package main
+
+import (
+	"fmt"
+	"net/url"
+	"os/exec"
+	"runtime"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/x/ansi"
+)
+
+var linkHotStyle = lipgloss.NewStyle().Bold(true).Underline(true).
+	Foreground(lipgloss.Color("#101010")).Background(lipgloss.Color("#61AFEF"))
+
+// linkSpan is a hyperlink on a rendered line: the display columns it covers
+// (from inclusive, to exclusive) and its target.
+type linkSpan struct {
+	from, to int
+	url      string
+}
+
+// linkSpans finds the OSC 8 hyperlinks on a rendered line, in display
+// columns. It understands BEL and ESC \ terminators and skips styling
+// sequences, so the columns match what the terminal draws.
+func linkSpans(line string) []linkSpan {
+	var spans []linkSpan
+	col, open, target := 0, -1, ""
+	for i := 0; i < len(line); {
+		if line[i] == 0x1b && i+1 < len(line) {
+			switch line[i+1] {
+			case ']':
+				end, next := -1, -1
+				for j := i + 2; j < len(line); j++ {
+					if line[j] == 0x07 {
+						end, next = j, j+1
+						break
+					}
+					if line[j] == 0x1b && j+1 < len(line) && line[j+1] == '\\' {
+						end, next = j, j+2
+						break
+					}
+				}
+				if end < 0 {
+					return spans
+				}
+				if payload := line[i+2 : end]; strings.HasPrefix(payload, "8;") {
+					parts := strings.SplitN(payload, ";", 3)
+					switch {
+					case len(parts) == 3 && parts[2] != "":
+						open, target = col, parts[2]
+					case open >= 0:
+						spans = append(spans, linkSpan{open, col, target})
+						open = -1
+					}
+				}
+				i = next
+				continue
+			case '[':
+				j := i + 2
+				for j < len(line) && !(line[j] >= 0x40 && line[j] <= 0x7e) {
+					j++
+				}
+				i = j + 1
+				continue
+			}
+		}
+		r, size := utf8.DecodeRuneInString(line[i:])
+		col += ansi.StringWidth(string(r))
+		i += size
+	}
+	return spans
+}
+
+// linkAt returns the link covering display column x on a rendered line.
+func linkAt(line string, x int) (linkSpan, bool) {
+	for _, s := range linkSpans(line) {
+		if x >= s.from && x < s.to {
+			return s, true
+		}
+	}
+	return linkSpan{}, false
+}
+
+// linkAllowed limits what a click may open. A board is written by an agent
+// pasting arbitrary text, so only web and mail links are opened — never a
+// file: path or an app's custom scheme.
+func linkAllowed(target string) bool {
+	u, err := url.Parse(target)
+	if err != nil {
+		return false
+	}
+	switch strings.ToLower(u.Scheme) {
+	case "http", "https", "mailto":
+		return true
+	}
+	return false
+}
+
+// openURL hands a link to the OS. A variable so tests do not launch a browser.
+var openURL = func(target string) error {
+	switch runtime.GOOS {
+	case "darwin":
+		return exec.Command("open", target).Start()
+	case "windows":
+		return exec.Command("rundll32", "url.dll,FileProtocolHandler", target).Start()
+	}
+	return exec.Command("xdg-open", target).Start()
+}
+
+func (m *model) openLink(target string) {
+	if !linkAllowed(target) {
+		m.notice = "won't open that kind of link"
+		return
+	}
+	if err := openURL(target); err != nil {
+		m.notice = fmt.Sprintf("couldn't open link: %v", err)
+		return
+	}
+	m.notice = "opened " + target
+}
+
+// paintLink turns the link's cells solid on a rendered line.
+func paintLink(line string, s linkSpan) string {
+	w := visibleWidth(line)
+	return ansi.Cut(line, 0, s.from) + linkHotStyle.Render(stripANSI(ansi.Cut(line, s.from, s.to))) + ansi.Cut(line, s.to, w)
+}
diff --git a/links_test.go b/links_test.go
new file mode 100644
index 0000000..a74b95c
--- /dev/null
+++ b/links_test.go
@@ -0,0 +1,144 @@
+package main
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/muesli/termenv"
+)
+
+const linkBoard = `# Board
+
+## 🧠 Needs you
+
+- Fixed it, see https://example.com/pull/7/files for details.
+  https://github.com/than/sidecar/pull/30
+  Ask: Did the deploy behave?
+  Next: review.
+`
+
+func linkModel(t *testing.T) (model, *[]string) {
+	t.Helper()
+	p := filepath.Join(t.TempDir(), "sidecar.md")
+	writeFile(t, p, linkBoard)
+	m := testModel(t, p)
+	m.mouse = true
+	var opened []string
+	prev := openURL
+	openURL = func(u string) error { opened = append(opened, u); return nil }
+	t.Cleanup(func() { openURL = prev })
+	return m, &opened
+}
+
+func TestLinkSpansFindLabelAndBareURLColumns(t *testing.T) {
+	m, _ := linkModel(t)
+	found := map[string]linkSpan{}
+	for _, ln := range m.renderedLines {
+		for _, s := range linkSpans(ln) {
+			found[s.url] = s
+			plain := stripANSI(ln)
+			if s.from >= s.to || s.to > visibleWidth(plain)+1 {
+				t.Fatalf("span %+v outside the line %q", s, plain)
+			}
+		}
+	}
+	if _, ok := found["https://example.com/pull/7/files"]; !ok {
+		t.Fatalf("inline link not found: %v", found)
+	}
+	if _, ok := found["https://github.com/than/sidecar/pull/30"]; !ok {
+		t.Fatalf("bare URL not found: %v", found)
+	}
+}
+
+func TestLinkSpanColumnsCoverTheDisplayText(t *testing.T) {
+	line := "ab " + hyperlink("https://x.test/a", "label") + " tail"
+	spans := linkSpans(line)
+	if len(spans) != 1 || spans[0].from != 3 || spans[0].to != 8 || spans[0].url != "https://x.test/a" {
+		t.Fatalf("spans %+v", spans)
+	}
+	// ST-terminated links and styling sequences before the link count the same.
+	st := "\x1b[31mab\x1b[0m \x1b]8;;https://y.test\x1b\\go\x1b]8;;\x1b\\"
+	if s := linkSpans(st); len(s) != 1 || s[0].from != 3 || s[0].to != 5 || s[0].url != "https://y.test" {
+		t.Fatalf("ST spans %+v", s)
+	}
+}
+
+func TestClickingALinkOpensItInsteadOfTheItem(t *testing.T) {
+	m, opened := linkModel(t)
+	m = clickAt(t, m, "https://example.com/pull/7", 1)
+	if len(*opened) != 1 || (*opened)[0] != "https://example.com/pull/7/files" {
+		t.Fatalf("opened %v", *opened)
+	}
+	if !strings.HasPrefix(m.notice, "opened ") {
+		t.Fatalf("notice %q", m.notice)
+	}
+	if m.itemSec != -1 {
+		t.Fatal("a link click should not also select or tick the item")
+	}
+}
+
+func TestClickingABareURLLineOpensIt(t *testing.T) {
+	m, opened := linkModel(t)
+	clickAt(t, m, "https://github.com/than", 3)
+	if len(*opened) != 1 || (*opened)[0] != "https://github.com/than/sidecar/pull/30" {
+		t.Fatalf("opened %v", *opened)
+	}
+}
+
+func TestClickNextToALinkStillActsOnTheItem(t *testing.T) {
+	m, opened := linkModel(t)
+	m = clickAt(t, m, "• Fixed it", 0) // the bullet, on the same line as a link
+	if len(*opened) != 0 || !strings.Contains(readFile(t, m.path), "[x] Fixed it") {
+		t.Fatalf("bullet click should tick, opened %v", *opened)
+	}
+}
+
+func TestOnlyWebAndMailLinksOpen(t *testing.T) {
+	for u, want := range map[string]bool{
+		"https://a.test": true, "http://a.test": true, "mailto:a@b.test": true,
+		"file:///etc/passwd": false, "javascript:alert(1)": false, "vscode://x": false, "ssh://h": false,
+	} {
+		if linkAllowed(u) != want {
+			t.Fatalf("linkAllowed(%q) = %v, want %v", u, !want, want)
+		}
+	}
+	m, opened := linkModel(t)
+	m.openLink("file:///etc/passwd")
+	if len(*opened) != 0 || !strings.Contains(m.notice, "won't open") {
+		t.Fatalf("opened %v, notice %q", *opened, m.notice)
+	}
+}
+
+func TestHoveringALinkPaintsItAndShowsTheAddress(t *testing.T) {
+	prev := lipgloss.ColorProfile()
+	lipgloss.SetColorProfile(termenv.TrueColor)
+	t.Cleanup(func() { lipgloss.SetColorProfile(prev) })
+	m, _ := linkModel(t)
+	rest := m.vp.View()
+	m = mouseAt(t, m, "https://example.com/pull/7", 1, tea.MouseActionMotion, tea.MouseButtonNone)
+	if m.hover.kind != hoverLink || m.vp.View() == rest || !strings.Contains(m.vp.View(), linkHotStyle.Render("https://example.com/pull/7/files")) {
+		t.Fatalf("hovering a link should paint it (hover %+v)", m.hover)
+	}
+	if bar := stripANSI(m.statusBar()); !strings.Contains(bar, "https://example.com/pull/7/files") {
+		t.Fatalf("status bar should show the full address: %q", bar)
+	}
+	m = mouseAt(t, m, "Next: review", 0, tea.MouseActionMotion, tea.MouseButtonNone)
+	if m.hover.line != -1 || m.vp.View() != rest {
+		t.Fatal("moving off the link should restore it")
+	}
+}
+
+func TestClicksAreHeldWhileTyping(t *testing.T) {
+	m, opened := linkModel(t)
+	m = press(t, m, "j", "a")
+	if !m.typing {
+		t.Fatal("setup: reply should be open")
+	}
+	m = clickAt(t, m, "https://example.com/pull/7", 1)
+	if len(*opened) != 0 || !m.typing || !strings.Contains(m.notice, "finish the reply") {
+		t.Fatalf("a click while typing must not act (opened %v, typing %v, notice %q)", *opened, m.typing, m.notice)
+	}
+}
diff --git a/marks.go b/marks.go
index c29c0d5..d8a9a06 100644
--- a/marks.go
+++ b/marks.go
@@ -245,6 +245,7 @@ const (
 	hoverNone hoverKind = iota
 	hoverBullet
 	hoverQuestion
+	hoverLink
 )
 
 // hoverTarget is the clickable thing under the pointer: the rendered lines
@@ -252,6 +253,7 @@ const (
 type hoverTarget struct {
 	line, last int
 	kind       hoverKind
+	link       linkSpan // for hoverLink
 }
 
 // bulletCells is how many columns from the left edge tick an item — the
@@ -268,6 +270,8 @@ func isQuestionLine(rendered string) bool {
 // a question goes bold and underlined.
 func paintHover(lines []string, h hoverTarget) {
 	switch h.kind {
+	case hoverLink:
+		lines[h.line] = paintLink(lines[h.line], h.link)
 	case hoverBullet:
 		l := lines[h.line]
 		lines[h.line] = bulletHotStyle.Render(stripANSI(ansi.Cut(l, 0, bulletCells))) + ansi.Cut(l, bulletCells, visibleWidth(l))
diff --git a/ui.go b/ui.go
index e2d17e9..1d4e37d 100644
--- a/ui.go
+++ b/ui.go
@@ -570,6 +570,8 @@ func (m model) statusBar() string {
 			shown = string([]rune(shown)[1:]) // keep the end, where the cursor is
 		}
 		info = lead + shown + "▌"
+	case m.hover.kind == hoverLink && m.hover.line >= 0:
+		info = "· ↗ " + m.hover.link.url
 	case m.notice != "":
 		info = "· " + m.notice
 	case h != "":