diff --git a/cli/internal/tui/app.go b/cli/internal/tui/app.go
index 9a211a6..018480b 100644
--- a/cli/internal/tui/app.go
+++ b/cli/internal/tui/app.go
@@ -27,6 +27,7 @@ const (
 	AppStatePageView
 	AppStateLogin
 	AppStateCapabilityPage
+	AppStateWebhooksPage
 )
 
 type sessionsLoadedMsg struct {
@@ -128,6 +129,7 @@ type AppModel struct {
 	PageView         PageViewModel
 	Login            LoginModel
 	CapabilityPage   CapabilityPageModel
+	WebhooksPage     WebhooksPageModel
 }
 
 // LoadPrefs applies the same display choices to the initial and future chats.
@@ -570,6 +572,7 @@ func (m AppModel) Update(msg tea.Msg) (result tea.Model, command tea.Cmd) {
 		m.ContextInspector.SetSize(msg.Width, msg.Height)
 		m.PageView.SetSize(msg.Width, msg.Height)
 		m.CapabilityPage.SetSize(msg.Width, msg.Height)
+		m.WebhooksPage.SetSize(msg.Width, msg.Height)
 		m.Login.SetSize(msg.Width, msg.Height)
 		return m, nil
 
@@ -813,14 +816,18 @@ func (m AppModel) Update(msg tea.Msg) (result tea.Model, command tea.Cmd) {
 			return m, m.ExtensionPicker.Init()
 		}
 
-	case ExtensionPickerOpenPageMsg:
+	case ChatOpenWebhooksPageMsg:
 		if m.ActiveSession != nil {
-			m.PageView = NewPageViewModel(m.Conn, m.ActiveSession.ID, msg.Command)
-			m.PageView.SetSize(m.Width, m.Height)
-			m.State = AppStatePageView
-			return m, m.PageView.Init()
+			m.WebhooksPage = NewWebhooksPageModel(m.Conn, m.ActiveSession.ID)
+			m.WebhooksPage.SetSize(m.Width, m.Height)
+			m.State = AppStateWebhooksPage
+			return m, m.WebhooksPage.Init()
 		}
 
+	case WebhooksPageDoneMsg:
+		m.State = AppStateChat
+		return m, nil
+
 	case ExtensionPickerDoneMsg:
 		m.State = AppStateChat
 		return m, nil
@@ -1085,6 +1092,8 @@ func (m AppModel) Update(msg tea.Msg) (result tea.Model, command tea.Cmd) {
 		m.PageView, cmd = m.PageView.Update(msg)
 	case AppStateCapabilityPage:
 		m.CapabilityPage, cmd = m.CapabilityPage.Update(msg)
+	case AppStateWebhooksPage:
+		m.WebhooksPage, cmd = m.WebhooksPage.Update(msg)
 	case AppStateLogin:
 		m.Login, cmd = m.Login.Update(msg)
 	}
@@ -1121,6 +1130,8 @@ func (m AppModel) View() string {
 		content = m.PageView.View()
 	case AppStateCapabilityPage:
 		content = m.CapabilityPage.View()
+	case AppStateWebhooksPage:
+		content = m.WebhooksPage.View()
 	case AppStateLogin:
 		content = m.Login.View()
 	}
diff --git a/cli/internal/tui/chat.go b/cli/internal/tui/chat.go
index d4f43fe..0365980 100644
--- a/cli/internal/tui/chat.go
+++ b/cli/internal/tui/chat.go
@@ -1425,6 +1425,8 @@ func (m *ChatModel) handleSubmittedCommand(input string, cmds *[]tea.Cmd) {
 	case trimmed == "/skills" || trimmed == "/instructions" || trimmed == "/mcp":
 		kind := strings.TrimPrefix(trimmed, "/")
 		*cmds = append(*cmds, func() tea.Msg { return ChatOpenCapabilityPageMsg{Kind: kind} })
+	case trimmed == "/webhooks":
+		*cmds = append(*cmds, func() tea.Msg { return ChatOpenWebhooksPageMsg{} })
 	case strings.HasPrefix(trimmed, "/login"):
 		name := strings.TrimSpace(strings.TrimPrefix(trimmed, "/login"))
 		*cmds = append(*cmds, func() tea.Msg { return ChatOpenLoginMsg{Name: name} })
diff --git a/cli/internal/tui/extension_picker.go b/cli/internal/tui/extension_picker.go
index e6ce7d2..565ca11 100644
--- a/cli/internal/tui/extension_picker.go
+++ b/cli/internal/tui/extension_picker.go
@@ -27,7 +27,6 @@ type ExtensionItem struct {
 }
 
 type ExtensionPickerDoneMsg struct{}
-type ExtensionPickerOpenPageMsg struct{ Command string }
 type ExtensionPickerChangedMsg struct{}
 
 type extensionsLoadedMsg struct {
@@ -268,7 +267,7 @@ func (m ExtensionPickerModel) Update(msg tea.Msg) (ExtensionPickerModel, tea.Cmd
 				m.Session = true
 			case "o":
 				if m.Cursor < len(m.Extensions) && m.Extensions[m.Cursor].Name == "webhooks" && m.Extensions[m.Cursor].Enabled {
-					return m, func() tea.Msg { return ExtensionPickerOpenPageMsg{Command: "/webhooks"} }
+					return m, func() tea.Msg { return ChatOpenWebhooksPageMsg{} }
 				}
 			case "x":
 				if m.Session && !m.NoGlobal && m.Cursor < len(m.Extensions) && m.Extensions[m.Cursor].Overridden {
@@ -417,15 +416,15 @@ func (m ExtensionPickerModel) View() string {
 		b.WriteString(m.Styles.Faint.Render("waiting for confirmation"))
 	} else {
 		keys := []hint{{"↑↓", "select"}, {"enter/space", "toggle"}, {"s", "this session"}, {"esc", "return to chat"}}
-		if m.Cursor < len(m.Extensions) && m.Extensions[m.Cursor].Name == "webhooks" && m.Extensions[m.Cursor].Enabled {
-			keys = append(keys, hint{"o", "open webhooks"})
-		}
 		if m.Session {
 			keys = []hint{{"↑↓", "select"}, {"enter/space", "toggle"}, {"x", "follow global"}, {"g", "global defaults"}, {"esc", "return to chat"}}
 			if m.NoGlobal {
 				keys = []hint{{"↑↓", "select"}, {"enter/space", "toggle"}, {"esc", "return to chat"}}
 			}
 		}
+		if m.Cursor < len(m.Extensions) && m.Extensions[m.Cursor].Name == "webhooks" && m.Extensions[m.Cursor].Enabled {
+			keys = append(keys, hint{"o", "open webhooks"})
+		}
 		b.WriteString(inkWrap(keyHints(keys...), m.Width))
 	}
 
diff --git a/cli/internal/tui/webhooks_page.go b/cli/internal/tui/webhooks_page.go
new file mode 100644
index 0000000..0afa872
--- /dev/null
+++ b/cli/internal/tui/webhooks_page.go
@@ -0,0 +1,811 @@
+package tui
+
+import (
+	"albedo/cli/internal/daemon"
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/x/ansi"
+)
+
+// WebhooksPageModel is the Webhooks screen: every signed endpoint grouped by
+// the session it wakes, their inboxes, and whether the agent of the session it
+// was opened from may manage its own. Every change runs /webhooks on the
+// daemon and then reloads, so the list is never patched locally.
+type WebhooksPageModel struct {
+	Conn      *daemon.Connection
+	SessionID string
+	// Sessions are the ones a hook can target, the current one first.
+	Sessions        []daemon.Session
+	Hooks           []webhookEntry
+	AgentManagement bool
+	// Mounted reports whether the extension is on globally; the daemon only
+	// listens for deliveries then.
+	Mounted                           bool
+	Cursor, Width, Height, Generation int
+	Loaded, Loading, Saving           bool
+	Confirm                           string // "delete" or "rotate"
+	Form                              *webhookForm
+	// Reveal holds a generated secret until it is dismissed; it is never
+	// fetched again.
+	Reveal        *webhookSecret
+	Error, Notice string
+}
+
+type webhookEntry struct {
+	ID       string
+	Session  string
+	Name     string
+	Enabled  bool
+	URL      string
+	Header   string
+	Prefix   string
+	Queued   int
+	Deferred string
+}
+
+type webhookSecret struct{ Hook, Session, Secret string }
+
+type webhooksLoadedMsg struct {
+	Sessions []daemon.Session
+	Hooks    []webhookEntry
+	Agent    bool
+	Mounted  bool
+	Gen      int
+	Err      error
+}
+
+type webhooksSavedMsg struct {
+	Notice string
+	Reveal *webhookSecret
+	Gen    int
+	Err    error
+}
+
+type WebhooksPageDoneMsg struct{}
+type ChatOpenWebhooksPageMsg struct{}
+
+const (
+	defaultSignatureHeader = "x-albedo-signature"
+	defaultSignaturePrefix = "sha256="
+)
+
+func NewWebhooksPageModel(conn *daemon.Connection, sessionID string) WebhooksPageModel {
+	return WebhooksPageModel{Conn: conn, SessionID: sessionID, Loading: true, Mounted: true}
+}
+
+func (m *WebhooksPageModel) SetSize(w, h int) {
+	m.Width = w
+	m.Height = h
+}
+
+func (m WebhooksPageModel) Init() tea.Cmd { return m.loadCmd(m.Generation) }
+
+// run calls /webhooks with an action and answers its result object.
+func (m WebhooksPageModel) run(action, details string) (map[string]any, error) {
+	if m.Conn == nil {
+		return nil, errors.New("daemon connection unavailable")
+	}
+	path := fmt.Sprintf("/sessions/%s/commands", url.PathEscape(m.SessionID))
+	body := map[string]any{"name": "/webhooks", "args": map[string]string{"action": action, "details": details}}
+	res, err := daemon.Request[map[string]any](context.Background(), m.Conn, path, body)
+	if err != nil {
+		return nil, err
+	}
+	if r, ok := res["result"].(map[string]any); ok {
+		return r, nil
+	}
+	return res, nil
+}
+
+func (m WebhooksPageModel) loadCmd(gen int) tea.Cmd {
+	return func() tea.Msg {
+		mounted := true
+		if m.Conn != nil {
+			path := fmt.Sprintf("/sessions/%s/extensions", url.PathEscape(m.SessionID))
+			if extensions, err := daemon.Request[[]ExtensionItem](context.Background(), m.Conn, path, nil); err == nil {
+				for _, ext := range extensions {
+					if ext.Name == "webhooks" {
+						mounted = ext.GlobalEnabled
+						if !ext.Enabled {
+							return webhooksLoadedMsg{Gen: gen, Err: errors.New("the webhooks extension is off for this session · turn it on in /extensions")}
+						}
+					}
+				}
+			}
+		}
+		var sessions []daemon.Session
+		if m.Conn != nil {
+			all, err := daemon.Request[[]daemon.Session](context.Background(), m.Conn, "/sessions", nil)
+			if err != nil {
+				return webhooksLoadedMsg{Gen: gen, Err: err}
+			}
+			for _, s := range all {
+				if s.ID == m.SessionID {
+					sessions = append([]daemon.Session{s}, sessions...)
+				} else {
+					sessions = append(sessions, s)
+				}
+			}
+		}
+		res, err := m.run("list", "")
+		if err != nil {
+			return webhooksLoadedMsg{Gen: gen, Err: err}
+		}
+		agent, _ := res["agentManagement"].(bool)
+		var hooks []webhookEntry
+		entries, _ := res["hooks"].([]any)
+		for _, raw := range entries {
+			entry, _ := raw.(map[string]any)
+			hook, ok := entry["hook"].(map[string]any)
+			if !ok {
+				continue
+			}
+			w := webhookEntry{}
+			w.ID, _ = hook["id"].(string)
+			w.Session, _ = hook["session"].(string)
+			w.Name, _ = hook["name"].(string)
+			w.Enabled, _ = hook["enabled"].(bool)
+			w.URL, _ = hook["url"].(string)
+			w.Header, _ = hook["signatureHeader"].(string)
+			w.Prefix, _ = hook["signaturePrefix"].(string)
+			if queued, ok := entry["queued"].(float64); ok {
+				w.Queued = int(queued)
+			}
+			w.Deferred, _ = entry["deferred"].(string)
+			if w.ID != "" {
+				hooks = append(hooks, w)
+			}
+		}
+		// Group by session in the order they are offered, current first.
+		order := map[string]int{}
+		for i, s := range sessions {
+			order[s.ID] = i
+		}
+		rank := func(id string) int {
+			if i, ok := order[id]; ok {
+				return i
+			}
+			return len(sessions)
+		}
+		sort.SliceStable(hooks, func(i, j int) bool { return rank(hooks[i].Session) < rank(hooks[j].Session) })
+		return webhooksLoadedMsg{Sessions: sessions, Hooks: hooks, Agent: agent, Mounted: mounted, Gen: gen}
+	}
+}
+
+// newHookID stands in for the id of a hook created by an earlier step.
+const newHookID = "{id}"
+
+// save runs steps in order and stops at the first failure; a generated secret
+// from any step is carried back to be shown once.
+func (m WebhooksPageModel) save(gen int, notice string, steps ...[2]string) tea.Cmd {
+	return func() tea.Msg {
+		var reveal *webhookSecret
+		created := ""
+		for _, step := range steps {
+			res, err := m.run(step[0], strings.Replace(step[1], newHookID, created, 1))
+			if err != nil {
+				if reveal != nil {
+					// The hook exists with this secret even though a later step
+					// failed, so it still has to be shown.
+					return webhooksSavedMsg{Reveal: reveal, Gen: gen, Err: err}
+				}
+				return webhooksSavedMsg{Gen: gen, Err: err}
+			}
+			hook, _ := res["hook"].(map[string]any)
+			if id, ok := hook["id"].(string); ok {
+				created = id
+			}
+			if secret, ok := res["secret"].(string); ok && secret != "" {
+				name, _ := hook["name"].(string)
+				session, _ := hook["session"].(string)
+				reveal = &webhookSecret{Hook: name, Session: session, Secret: secret}
+			}
+		}
+		return webhooksSavedMsg{Notice: notice, Reveal: reveal, Gen: gen}
+	}
+}
+
+func (m WebhooksPageModel) selected() *webhookEntry {
+	if m.Cursor < len(m.Hooks) {
+		return &m.Hooks[m.Cursor]
+	}
+	return nil
+}
+
+// sessionLabel names a session plainly enough to tell it apart from the
+// others. Whether it is the session this screen was opened from comes first,
+// and the title is capped, so a long title never hides the rest.
+func sessionLabel(sessions []daemon.Session, id, current string) string {
+	parts := []string{"session " + id[:min(8, len(id))]}
+	for _, s := range sessions {
+		if s.ID == id {
+			parts = []string{ansi.Truncate(sessionTitle(s), 32, "…")}
+			if s.Workspace != "" {
+				parts = append(parts, homePath(s.Workspace))
+			}
+			break
+		}
+	}
+	if id == current {
+		parts = append([]string{"this session"}, parts...)
+	}
+	return strings.Join(parts, " · ")
+}
+
+// address is where a sender posts: the daemon's local address, which a
+// reverse proxy can expose.
+func (m WebhooksPageModel) address(hook webhookEntry) string {
+	if m.Conn == nil || m.Conn.Port == 0 {
+		return hook.URL
+	}
+	return fmt.Sprintf("http://127.0.0.1:%d%s", m.Conn.Port, hook.URL)
+}
+
+func (m WebhooksPageModel) begin(notice string, steps ...[2]string) (WebhooksPageModel, tea.Cmd) {
+	m.Error, m.Notice = "", ""
+	m.Saving = true
+	m.Generation++
+	return m, m.save(m.Generation, notice, steps...)
+}
+
+func (m WebhooksPageModel) Update(msg tea.Msg) (WebhooksPageModel, tea.Cmd) {
+	switch msg := msg.(type) {
+	case webhooksLoadedMsg:
+		if msg.Gen != m.Generation {
+			return m, nil
+		}
+		m.Loading = false
+		if msg.Err != nil {
+			m.Error = msg.Err.Error()
+			return m, nil
+		}
+		selected := ""
+		if hook := m.selected(); hook != nil {
+			selected = hook.ID
+		}
+		m.Loaded = true
+		m.Sessions, m.Hooks, m.AgentManagement, m.Mounted = msg.Sessions, msg.Hooks, msg.Agent, msg.Mounted
+		for i, hook := range m.Hooks {
+			if hook.ID == selected {
+				m.Cursor = i
+				break
+			}
+		}
+		m.Cursor = max(0, min(m.Cursor, len(m.Hooks)-1))
+		return m, nil
+	case webhooksSavedMsg:
+		if msg.Gen != m.Generation {
+			return m, nil
+		}
+		m.Saving = false
+		m.Reveal = msg.Reveal
+		if msg.Err != nil {
+			m.Error = msg.Err.Error()
+			if msg.Reveal == nil {
+				return m, nil
+			}
+		} else {
+			m.Form = nil
+			m.Notice = msg.Notice
+		}
+		m.Loading = true
+		m.Generation++
+		return m, m.loadCmd(m.Generation)
+	case tea.KeyMsg:
+		if m.Saving {
+			return m, nil
+		}
+		if m.Reveal != nil {
+			switch {
+			case msg.String() == "c":
+				if err := CopyText(m.Reveal.Secret); err != nil {
+					m.Error = "copy failed: " + err.Error()
+				} else {
+					m.Error, m.Notice = "", "secret copied"
+				}
+			case msg.Type == tea.KeyEnter || msg.Type == tea.KeyEsc:
+				m.Reveal = nil
+			}
+			return m, nil
+		}
+		if m.Form != nil {
+			if msg.Type == tea.KeyEsc {
+				m.Form = nil
+				m.Error = ""
+				return m, nil
+			}
+			submit, cmd := m.Form.update(msg)
+			if !submit {
+				return m, cmd
+			}
+			steps, notice, err := m.Form.steps()
+			if err != nil {
+				m.Error = err.Error()
+				return m, nil
+			}
+			if len(steps) == 0 {
+				m.Form = nil
+				m.Error, m.Notice = "", "nothing changed"
+				return m, nil
+			}
+			return m.begin(notice, steps...)
+		}
+		if m.Confirm != "" {
+			confirm := m.Confirm
+			m.Confirm = ""
+			hook := m.selected()
+			if msg.Type != tea.KeyEnter || hook == nil {
+				return m, nil
+			}
+			if confirm == "delete" {
+				return m.begin("deleted "+hook.Name, [2]string{"delete", hook.ID})
+			}
+			return m.begin("new secret for "+hook.Name, [2]string{"rotate", hook.ID})
+		}
+		if msg.Type == tea.KeyEsc || msg.Type == tea.KeyCtrlC {
+			return m, func() tea.Msg { return WebhooksPageDoneMsg{} }
+		}
+		if m.Loading {
+			return m, nil
+		}
+		if msg.String() == "r" {
+			m.Error, m.Notice = "", ""
+			m.Loading = true
+			m.Generation++
+			return m, m.loadCmd(m.Generation)
+		}
+		if !m.Loaded {
+			return m, nil
+		}
+		hook := m.selected()
+		switch msg.Type {
+		case tea.KeyUp, tea.KeyCtrlP:
+			m.Cursor = max(0, m.Cursor-1)
+		case tea.KeyDown, tea.KeyCtrlN:
+			m.Cursor = min(max(0, len(m.Hooks)-1), m.Cursor+1)
+		case tea.KeyEnter:
+			if hook != nil {
+				m.Error, m.Notice = "", ""
+				m.Form = newWebhookForm(hook, m.Sessions, m.SessionID)
+			}
+		case tea.KeySpace:
+			if hook != nil {
+				if hook.Enabled {
+					return m.begin(hook.Name+" off · deliveries now answer 404", [2]string{"disable", hook.ID})
+				}
+				return m.begin(hook.Name+" on", [2]string{"enable", hook.ID})
+			}
+		case tea.KeyRunes:
+			switch msg.String() {
+			case "n":
+				m.Error, m.Notice = "", ""
+				m.Form = newWebhookForm(nil, m.Sessions, m.SessionID)
+			case "a":
+				if m.AgentManagement {
+					return m.begin("this session's agent can no longer manage its hooks", [2]string{"agent_off", ""})
+				}
+				return m.begin("this session's agent can now manage its own hooks", [2]string{"agent_on", ""})
+			case "d":
+				if hook != nil {
+					m.Confirm = "delete"
+				}
+			case "k":
+				if hook != nil {
+					m.Confirm = "rotate"
+				}
+			case "y":
+				if hook != nil {
+					if err := CopyText(m.address(*hook)); err != nil {
+						m.Error = "copy failed: " + err.Error()
+					} else {
+						m.Error, m.Notice = "", "url copied"
+					}
+				}
+			}
+		}
+	}
+	return m, nil
+}
+
+func (m WebhooksPageModel) View() string {
+	width := max(1, m.Width)
+	rows := []string{titleRule(width, brand("albedo")+" "+DefaultStyles.Muted.Render("/webhooks"), DefaultStyles.Faint.Render("all sessions")), ""}
+	if m.Error != "" {
+		rows = append(rows, DefaultStyles.Error.Render(ansi.Truncate(m.Error, width, "…")))
+	}
+	if m.Notice != "" {
+		rows = append(rows, DefaultStyles.Faint.Render(ansi.Truncate(m.Notice, width, "…")))
+	}
+	if m.Loading && !m.Loaded {
+		rows = append(rows, DefaultStyles.Faint.Render("loading webhooks…"))
+		return strings.Join(rows, "\n")
+	}
+	if !m.Loaded {
+		return strings.Join(append(rows, "", keyHints(hint{"r", "retry"}, hint{"esc", "back"})), "\n")
+	}
+	if !m.Mounted {
+		rows = append(rows, DefaultStyles.Warning.Render("not listening")+DefaultStyles.Faint.Render(" · enable webhooks globally in /extensions to accept deliveries"))
+	}
+	agent := DefaultStyles.Faint.Render("off") + DefaultStyles.Faint.Render(" · this session's agent can't touch webhooks")
+	if m.AgentManagement {
+		agent = DefaultStyles.Success.Render("on ") + DefaultStyles.Faint.Render(" · this session's agent can add, rotate and delete its own hooks")
+	}
+	rows = append(rows, ansi.Truncate(DefaultStyles.Muted.Render("agent access ")+agent, width, "…"), "")
+
+	if len(m.Hooks) == 0 {
+		rows = append(rows, DefaultStyles.Faint.Render("no webhooks yet · each one is a signed URL that wakes a session"))
+	}
+	nameWidth := 4
+	for _, hook := range m.Hooks {
+		nameWidth = max(nameWidth, ansi.StringWidth(hook.Name))
+	}
+	// Hooks sit under the session they wake; the cursor line is kept in view.
+	var list []string
+	cursorLine := 0
+	for i, hook := range m.Hooks {
+		if i == 0 || hook.Session != m.Hooks[i-1].Session {
+			count := 0
+			for _, other := range m.Hooks {
+				if other.Session == hook.Session {
+					count++
+				}
+			}
+			if i > 0 {
+				list = append(list, "")
+			}
+			list = append(list, sectionRule(ansi.Truncate(sessionLabel(m.Sessions, hook.Session, m.SessionID), max(8, width-12), "…"), count, width))
+		}
+		label := DefaultStyles.Success.Render("on ")
+		if !hook.Enabled {
+			label = DefaultStyles.Faint.Render("off")
+		}
+		mark := "  "
+		if i == m.Cursor {
+			mark = selectBar() + " "
+		}
+		row := mark + label + "  " + padRight(hook.Name, nameWidth+1) + DefaultStyles.Faint.Render(hook.URL)
+		if hook.Queued > 0 {
+			row += DefaultStyles.Decor.Render(" · ") + DefaultStyles.Warning.Render(fmt.Sprintf("%d queued", hook.Queued))
+		}
+		row = ansi.Truncate(row, width, "…")
+		if i == m.Cursor {
+			row = selectedLine(row, width)
+			cursorLine = len(list)
+		}
+		list = append(list, row)
+	}
+	listRows := max(2, m.Height-17)
+	start := max(0, cursorLine-listRows+1)
+	rows = append(rows, list[start:min(len(list), start+listRows)]...)
+
+	switch {
+	case m.Reveal != nil:
+		rows = append(rows, "", ansi.Truncate(DefaultStyles.Bold.Render("signing secret for "+m.Reveal.Hook)+DefaultStyles.Faint.Render(" → "+sessionLabel(m.Sessions, m.Reveal.Session, m.SessionID)+" · shown once, copy it now"), width, "…"))
+		rows = append(rows, "  "+DefaultStyles.Prompt.Render(m.Reveal.Secret), "")
+		rows = append(rows, keyHints(hint{"c", "copy"}, hint{"enter", "done"}))
+	case m.Form != nil:
+		rows = append(rows, "")
+		rows = append(rows, m.Form.view(width)...)
+		if m.Saving {
+			rows = append(rows, DefaultStyles.Faint.Render("saving…"))
+		}
+	case m.Confirm != "" && m.selected() != nil:
+		question := "delete " + m.selected().Name + "? its URL stops working; accepted deliveries stay in the inbox"
+		if m.Confirm == "rotate" {
+			question = "replace the secret for " + m.selected().Name + "? the sender must be updated"
+		}
+		rows = append(rows, "", DefaultStyles.Warning.Render(ansi.Truncate(question, width, "…")), keyHints(hint{"enter", "confirm"}, hint{"any other key", "cancels"}))
+	case m.Saving:
+		rows = append(rows, "", DefaultStyles.Faint.Render("saving…"))
+	default:
+		if hook := m.selected(); hook != nil {
+			rows = append(rows, "")
+			rows = append(rows, m.detail(*hook, width)...)
+		}
+		browse := []hint{{"r", "refresh"}, {"esc", "back"}}
+		keys := []hint{{"n", "add hook"}, {"a", "agent access"}}
+		if len(m.Hooks) > 0 {
+			browse = append([]hint{{"↑↓", "select"}, {"space", "on/off"}, {"y", "copy url"}}, browse...)
+			keys = []hint{{"n", "add hook"}, {"enter", "edit"}, {"k", "new secret"}, {"d", "delete"}, {"a", "agent access"}}
+		}
+		rows = append(rows, "", keyHints(browse...), keyHints(keys...))
+	}
+	if m.Height > 0 && len(rows) > m.Height {
+		rows = append(rows[:max(1, m.Height-1)], rows[len(rows)-1])
+	}
+	return strings.Join(rows, "\n")
+}
+
+// detail explains the selected hook: where to send, how to sign, and what is
+// waiting for the session.
+func (m WebhooksPageModel) detail(hook webhookEntry, width int) []string {
+	field := func(label, value string) string {
+		return ansi.Truncate(DefaultStyles.Muted.Render(padRight(label, 11))+value, width, "…")
+	}
+	rows := []string{
+		field("wakes", sessionLabel(m.Sessions, hook.Session, m.SessionID)),
+		field("url", "POST "+m.address(hook)),
+		field("signature", hook.Header+": "+hook.Prefix+DefaultStyles.Faint.Render("<hex HMAC-SHA256 of the body>")),
+	}
+	inbox := DefaultStyles.Faint.Render("empty")
+	if hook.Queued > 0 {
+		inbox = DefaultStyles.Warning.Render(fmt.Sprintf("%d waiting for the session", hook.Queued))
+		if hook.Deferred != "" {
+			inbox += DefaultStyles.Faint.Render(" · last attempt: " + hook.Deferred)
+		}
+	}
+	if !hook.Enabled {
+		inbox += DefaultStyles.Faint.Render(" · off, new deliveries answer 404")
+	}
+	return append(rows, field("inbox", inbox))
+}
+
+// webhookForm adds a hook or edits one on a single screen: the session it
+// wakes, its name, signing secret, and the header and prefix its sender signs
+// with. The session and name are fixed once the hook exists.
+type webhookForm struct {
+	// Editing is the hook being edited; nil for a new hook.
+	Editing *webhookEntry
+	Focus   int
+	Inputs  map[string]*textinput.Model
+	// Sessions are offered in order; Chosen starts at Current, the session
+	// the screen was opened from.
+	Sessions        []daemon.Session
+	Current, Chosen string
+}
+
+const (
+	hookFieldSession = "session"
+	hookFieldName    = "name"
+	hookFieldSecret  = "secret"
+	hookFieldHeader  = "header"
+	hookFieldPrefix  = "prefix"
+)
+
+var hookFields = []string{hookFieldSession, hookFieldName, hookFieldSecret, hookFieldHeader, hookFieldPrefix}
+
+// sessionChoices is how many matching sessions the picker shows at once.
+const sessionChoices = 5
+
+var (
+	hookName   = regexp.MustCompile(`^[A-Za-z0-9_-]{1,64}$`)
+	hookHeader = regexp.MustCompile(`^[A-Za-z0-9-]{1,64}$`)
+)
+
+func newWebhookForm(editing *webhookEntry, sessions []daemon.Session, current string) *webhookForm {
+	f := &webhookForm{Inputs: map[string]*textinput.Model{}, Sessions: sessions, Current: current, Chosen: current}
+	for _, key := range hookFields {
+		input := textinput.New()
+		input.Prompt = ""
+		input.CharLimit = 4096
+		f.Inputs[key] = &input
+	}
+	f.Inputs[hookFieldSession].Placeholder = "type to filter"
+	f.Inputs[hookFieldSecret].EchoMode = textinput.EchoPassword
+	f.Inputs[hookFieldName].Placeholder = "github-deploys"
+	f.Inputs[hookFieldHeader].SetValue(defaultSignatureHeader)
+	f.Inputs[hookFieldPrefix].SetValue(defaultSignaturePrefix)
+	f.Inputs[hookFieldSecret].Placeholder = "blank generates one"
+	f.Focus = 1 // the session already defaults to this one
+	if editing != nil {
+		hook := *editing
+		f.Editing = &hook
+		f.Chosen = hook.Session
+		f.Inputs[hookFieldName].SetValue(hook.Name)
+		f.Inputs[hookFieldHeader].SetValue(hook.Header)
+		f.Inputs[hookFieldPrefix].SetValue(hook.Prefix)
+		f.Inputs[hookFieldSecret].Placeholder = "stored · blank keeps it"
+		f.Focus = 2
+	}
+	f.focus()
+	return f
+}
+
+func (f *webhookForm) current() string { return hookFields[f.Focus] }
+
+func (f *webhookForm) focus() {
+	for key, input := range f.Inputs {
+		if key == f.current() {
+			input.Focus()
+		} else {
+			input.Blur()
+		}
+	}
+}
+
+func (f *webhookForm) move(delta int) {
+	first := 0
+	if f.Editing != nil {
+		first = 2
+	}
+	n := len(hookFields) - first
+	f.Focus = first + (f.Focus-first+delta+n)%n
+	f.focus()
+}
+
+// matches are the sessions the picker's filter leaves, in order.
+func (f *webhookForm) matches() []daemon.Session {
+	query := strings.ToLower(strings.TrimSpace(f.Inputs[hookFieldSession].Value()))
+	var out []daemon.Session
+	for _, s := range f.Sessions {
+		if query == "" || strings.Contains(strings.ToLower(sessionTitle(s)+" "+homePath(s.Workspace)+" "+s.ID), query) {
+			out = append(out, s)
+		}
+	}
+	return out
+}
+
+func (f *webhookForm) chosenIndex(matches []daemon.Session) int {
+	for i, s := range matches {
+		if s.ID == f.Chosen {
+			return i
+		}
+	}
+	return -1
+}
+
+// update handles one key; submit reports that the form should be saved.
+func (f *webhookForm) update(msg tea.KeyMsg) (submit bool, cmd tea.Cmd) {
+	switch msg.Type {
+	case tea.KeyTab, tea.KeyDown:
+		f.move(1)
+		return false, nil
+	case tea.KeyShiftTab, tea.KeyUp:
+		f.move(-1)
+		return false, nil
+	case tea.KeyCtrlS:
+		return true, nil
+	case tea.KeyEnter:
+		if f.Focus == len(hookFields)-1 {
+			return true, nil
+		}
+		f.move(1)
+		return false, nil
+	}
+	if f.current() == hookFieldSession {
+		matches := f.matches()
+		if (msg.Type == tea.KeyLeft || msg.Type == tea.KeyRight) && len(matches) > 0 {
+			step := 1
+			if msg.Type == tea.KeyLeft {
+				step = -1
+			}
+			i := f.chosenIndex(matches)
+			if i < 0 {
+				i = 0
+			} else {
+				i = (i + step + len(matches)) % len(matches)
+			}
+			f.Chosen = matches[i].ID
+			return false, nil
+		}
+	}
+	input := f.Inputs[f.current()]
+	next, cmd := input.Update(msg)
+	*input = next
+	if f.current() == hookFieldSession {
+		if matches := f.matches(); len(matches) > 0 && f.chosenIndex(matches) < 0 {
+			f.Chosen = matches[0].ID
+		}
+	}
+	return false, cmd
+}
+
+// steps turns the form into /webhooks calls, after checking what the daemon
+// would otherwise reject one step in.
+func (f *webhookForm) steps() ([][2]string, string, error) {
+	value := func(key string) string { return strings.TrimSpace(f.Inputs[key].Value()) }
+	name, secret, header, prefix := value(hookFieldName), value(hookFieldSecret), value(hookFieldHeader), value(hookFieldPrefix)
+	switch {
+	case f.Editing == nil && f.Chosen == "":
+		return nil, "", errors.New("session: choose the session this hook wakes")
+	case f.Editing == nil && !hookName.MatchString(name):
+		return nil, "", errors.New("name: use 1–64 letters, digits, _ or -")
+	case secret != "" && (len(secret) < 16 || len(secret) > 4096):
+		return nil, "", errors.New("secret: use 16–4096 bytes, or leave it blank")
+	case strings.ContainsAny(secret, " \t"):
+		return nil, "", errors.New("secret: spaces are not allowed")
+	case !hookHeader.MatchString(header):
+		return nil, "", errors.New("header: use 1–64 letters, digits or -")
+	case len(prefix) > 32 || strings.ContainsAny(prefix, " \t"):
+		return nil, "", errors.New("prefix: at most 32 characters, no spaces")
+	}
+	if f.Editing == nil {
+		create := f.Chosen + " " + name
+		if secret != "" {
+			create += " " + secret
+		}
+		steps := [][2]string{{"create_in", create}}
+		if !strings.EqualFold(header, defaultSignatureHeader) || prefix != defaultSignaturePrefix {
+			steps = append(steps, [2]string{"signature", newHookID + " " + header + " " + prefix})
+		}
+		return steps, "added " + name + " · wakes " + sessionLabel(f.Sessions, f.Chosen, f.Current), nil
+	}
+	hook := f.Editing
+	var steps [][2]string
+	if !strings.EqualFold(header, hook.Header) || prefix != hook.Prefix {
+		steps = append(steps, [2]string{"signature", hook.ID + " " + header + " " + prefix})
+	}
+	if secret != "" {
+		steps = append(steps, [2]string{"rotate_with_secret", hook.ID + " " + secret})
+	}
+	return steps, "saved " + hook.Name, nil
+}
+
+func (f *webhookForm) view(width int) []string {
+	title := "add webhook"
+	if f.Editing != nil {
+		title = "edit " + f.Editing.Name
+	}
+	rows := []string{DefaultStyles.Bold.Render(title)}
+	indent := strings.Repeat(" ", 13)
+	for i, key := range hookFields {
+		mark := "  "
+		if i == f.Focus {
+			mark = promptLead()
+		}
+		value := f.Inputs[key].View()
+		switch {
+		case key == hookFieldSession && f.Editing != nil:
+			value = DefaultStyles.Faint.Render(sessionLabel(f.Sessions, f.Chosen, f.Current))
+		case key == hookFieldSession && i != f.Focus:
+			value = sessionLabel(f.Sessions, f.Chosen, f.Current)
+		case key == hookFieldName && f.Editing != nil:
+			value = DefaultStyles.Faint.Render(f.Editing.Name)
+		}
+		rows = append(rows, ansi.Truncate(mark+padRight(key, 11)+value, width, "…"))
+		if key == hookFieldSession && i == f.Focus {
+			rows = append(rows, f.pickerRows(indent, width)...)
+		}
+	}
+	var note string
+	keys := []hint{{"tab/↑↓", "move"}, {"enter", "next"}, {"ctrl+s", "save"}, {"esc", "cancel"}}
+	switch f.current() {
+	case hookFieldSession:
+		note = "which session deliveries wake"
+		keys = append([]hint{{"←→", "choose"}}, keys...)
+	case hookFieldName:
+		note = "letters, digits, _ or -"
+	case hookFieldSecret:
+		note = "16+ bytes from the sender, or blank to generate one"
+		if f.Editing != nil {
+			note = "enter a new secret to replace the stored one"
+		}
+	case hookFieldHeader:
+		note = "the header the sender signs with · GitHub uses x-hub-signature-256"
+	case hookFieldPrefix:
+		note = "text before the hex digest · blank for none"
+	}
+	line := DefaultStyles.Faint.Render(note) + DefaultStyles.Decor.Render(" · ") + keyHints(keys...)
+	return append(rows, "", ansi.Truncate(line, width, "…"))
+}
+
+// pickerRows lists the matching sessions around the chosen one.
+func (f *webhookForm) pickerRows(indent string, width int) []string {
+	matches := f.matches()
+	if len(matches) == 0 {
+		return []string{indent + DefaultStyles.Faint.Render("no session matches")}
+	}
+	chosen := max(0, f.chosenIndex(matches))
+	start := max(0, min(chosen-sessionChoices/2, len(matches)-sessionChoices))
+	var rows []string
+	for i := start; i < min(len(matches), start+sessionChoices); i++ {
+		label := sessionLabel(f.Sessions, matches[i].ID, f.Current)
+		if i == chosen {
+			rows = append(rows, indent+selectedLine(ansi.Truncate(selectBar()+" "+label, width-len(indent), "…"), width-len(indent)))
+		} else {
+			rows = append(rows, indent+DefaultStyles.Faint.Render(ansi.Truncate("  "+label, width-len(indent), "…")))
+		}
+	}
+	if more := len(matches) - sessionChoices; more > 0 {
+		rows = append(rows, indent+DefaultStyles.Faint.Render(fmt.Sprintf("  %d more · type to filter", more)))
+	}
+	return rows
+}
diff --git a/cli/internal/tui/webhooks_page_test.go b/cli/internal/tui/webhooks_page_test.go
new file mode 100644
index 0000000..abc8ae5
--- /dev/null
+++ b/cli/internal/tui/webhooks_page_test.go
@@ -0,0 +1,125 @@
+package tui
+
+import (
+	"albedo/cli/internal/daemon"
+	"strings"
+	"testing"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/x/ansi"
+)
+
+var webhookSessions = []daemon.Session{
+	{ID: "s", Title: "infra bot", Workspace: "/srv/infra"},
+	{ID: "t", Title: "release notes", Workspace: "/srv/docs"},
+}
+
+func loadedWebhooksPage(t *testing.T) WebhooksPageModel {
+	t.Helper()
+	m := NewWebhooksPageModel(nil, "s")
+	m.SetSize(100, 30)
+	m, _ = m.Update(webhooksLoadedMsg{Mounted: true, Sessions: webhookSessions, Hooks: []webhookEntry{
+		{ID: "wh1", Session: "s", Name: "deploy", Enabled: true, URL: "/webhooks/wh1", Header: "x-hub-signature-256", Prefix: "sha256=", Queued: 2, Deferred: "session busy"},
+		{ID: "wh2", Session: "t", Name: "grafana", URL: "/webhooks/wh2", Header: "x-albedo-signature", Prefix: "sha256="},
+	}})
+	return m
+}
+
+func TestWebhooksPageExplainsTheSelectedHook(t *testing.T) {
+	view := ansi.Strip(loadedWebhooksPage(t).View())
+	for _, want := range []string{"agent access off", "this session · infra bot · /srv/infra", "release notes · /srv/docs", "wakes      this session · infra bot", "deploy", "2 queued", "POST /webhooks/wh1", "x-hub-signature-256: sha256=", "2 waiting for the session", "session busy", "n add hook"} {
+		if !strings.Contains(view, want) {
+			t.Fatalf("view is missing %q:\n%s", want, view)
+		}
+	}
+}
+
+func TestWebhookFormSetsSignatureOnTheCreatedHook(t *testing.T) {
+	f := newWebhookForm(nil, webhookSessions, "s")
+	f.Inputs[hookFieldName].SetValue("deploy")
+	f.Inputs[hookFieldHeader].SetValue("x-hub-signature-256")
+	steps, _, err := f.steps()
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := [][2]string{{"create_in", "s deploy"}, {"signature", newHookID + " x-hub-signature-256 sha256="}}
+	if len(steps) != 2 || steps[0] != want[0] || steps[1] != want[1] {
+		t.Fatalf("steps = %v", steps)
+	}
+
+	f.Inputs[hookFieldSecret].SetValue("short")
+	if _, _, err := f.steps(); err == nil || !strings.HasPrefix(err.Error(), "secret") {
+		t.Fatalf("short secret accepted: %v", err)
+	}
+}
+
+func TestWebhookEditOnlySendsWhatChanged(t *testing.T) {
+	m := loadedWebhooksPage(t)
+	m, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	if m.Form == nil || m.Form.current() != hookFieldSecret || m.Form.Chosen != "s" {
+		t.Fatal("enter should edit the selected hook, starting at its secret")
+	}
+	if steps, _, _ := m.Form.steps(); len(steps) != 0 {
+		t.Fatalf("unchanged form produced %v", steps)
+	}
+	m.Form.Inputs[hookFieldSecret].SetValue("a-new-sixteen-byte-secret")
+	steps, _, err := m.Form.steps()
+	if err != nil || len(steps) != 1 || steps[0] != [2]string{"rotate_with_secret", "wh1 a-new-sixteen-byte-secret"} {
+		t.Fatalf("steps = %v, %v", steps, err)
+	}
+	if strings.Contains(m.View(), "a-new-sixteen-byte-secret") {
+		t.Fatal("an entered secret was rendered")
+	}
+}
+
+func TestGeneratedSecretIsShownUntilDismissed(t *testing.T) {
+	m := loadedWebhooksPage(t)
+	m.Saving = true
+	m, _ = m.Update(webhooksSavedMsg{Gen: m.Generation, Notice: "added ci", Reveal: &webhookSecret{Hook: "ci", Secret: "whsec_generated"}})
+	if !strings.Contains(m.View(), "whsec_generated") {
+		t.Fatal("generated secret was not shown")
+	}
+	m, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'d'}})
+	if m.Reveal == nil || m.Confirm != "" {
+		t.Fatal("keys other than enter must not dismiss the secret")
+	}
+	m, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	if m.Reveal != nil || strings.Contains(m.View(), "whsec_generated") {
+		t.Fatal("secret should be gone once dismissed")
+	}
+}
+
+func TestLongSessionTitlesKeepTheirPlace(t *testing.T) {
+	sessions := []daemon.Session{{ID: "s", Title: strings.Repeat("webhook payload text ", 6), Workspace: "/srv/infra"}}
+	label := sessionLabel(sessions, "s", "s")
+	if !strings.HasPrefix(label, "this session · ") || !strings.HasSuffix(label, "… · /srv/infra") {
+		t.Fatalf("label = %q", label)
+	}
+}
+
+func TestWebhookFormPicksTheSessionToWake(t *testing.T) {
+	m := loadedWebhooksPage(t)
+	m, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'n'}})
+	if m.Form.Chosen != "s" || !strings.Contains(ansi.Strip(m.View()), "session    this session · infra bot · /srv/infra") {
+		t.Fatalf("the form should default to the session it was opened from:\n%s", ansi.Strip(m.View()))
+	}
+	m, _ = m.Update(tea.KeyMsg{Type: tea.KeyShiftTab})
+	for _, r := range "release" {
+		m, _ = m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}})
+	}
+	if m.Form.Chosen != "t" {
+		t.Fatalf("filtering should choose the matching session, got %q", m.Form.Chosen)
+	}
+	m, _ = m.Update(tea.KeyMsg{Type: tea.KeyBackspace})
+	m.Form.Inputs[hookFieldSession].SetValue("")
+	m, _ = m.Update(tea.KeyMsg{Type: tea.KeyLeft})
+	if m.Form.Chosen != "s" {
+		t.Fatalf("← should step back to the first session, got %q", m.Form.Chosen)
+	}
+	m, _ = m.Update(tea.KeyMsg{Type: tea.KeyRight})
+	m.Form.Inputs[hookFieldName].SetValue("notes")
+	steps, notice, err := m.Form.steps()
+	if err != nil || steps[0] != [2]string{"create_in", "t notes"} || !strings.Contains(notice, "release notes") {
+		t.Fatalf("steps = %v, %q, %v", steps, notice, err)
+	}
+}
diff --git a/docs/webhooks.md b/docs/webhooks.md
index 8782198..4fd27d3 100644
--- a/docs/webhooks.md
+++ b/docs/webhooks.md
@@ -4,9 +4,9 @@ Webhooks wake an existing session. An infra session can retain its history, memo
 
 ## Setup
 
-1. Open `/extensions`, select **webhooks**, and enable it **globally** to mount the incoming HTTP service. Press `o` on the enabled entry to open this session's Webhooks page (or open `/webhooks` directly).
-2. Add a named hook. Choose a generated signing secret (copy it when shown) or supply a secret of 16–4096 bytes. The displayed URL is `/webhooks/<opaque-id>`; it targets this session, even when no TUI is attached. The hook name must use 1–64 ASCII letters, digits, `_`, or `-`.
-3. Configure the sender to POST a body of at most 64 KiB with `X-Albedo-Signature: sha256=<lowercase or uppercase HMAC-SHA256 hex>` computed over **the exact bytes sent** using the hook secret. The header defaults to `x-albedo-signature`; the page lets you change its name or the signature prefix (for example, GitHub uses `x-hub-signature-256`).
+1. Open `/extensions`, select **webhooks**, and enable it **globally** to mount the incoming HTTP service. Press `o` on the enabled entry to open this session's Webhooks screen (or type `/webhooks`).
+2. Press `n` to add a named hook. Its **session** field picks the session deliveries wake; it defaults to the one you opened the screen from, and typing filters the list. The screen lists every session's hooks grouped under the session they wake, and the selected hook's **wakes** line names it. Leave the secret blank to generate one (it is shown once; `c` copies it) or supply a secret of 16–4096 bytes. `y` copies the selected hook's URL. The displayed URL is `/webhooks/<opaque-id>`; it targets the chosen session, even when no TUI is attached. The hook name must use 1–64 ASCII letters, digits, `_`, or `-`.
+3. Configure the sender to POST a body of at most 64 KiB with `X-Albedo-Signature: sha256=<lowercase or uppercase HMAC-SHA256 hex>` computed over **the exact bytes sent** using the hook secret. The header defaults to `x-albedo-signature`; the add/edit form sets its name and the signature prefix (for example, GitHub uses `x-hub-signature-256`).
 4. For retries, send a stable `X-Albedo-Event-Id` (1–128 bytes, no newlines). A retry with the same hook, ID, and body returns the original delivery ID; reuse with different bytes returns 409. Without this header, each valid POST is a separate event.
 
 The daemon binds to `127.0.0.1`. Set `ALBEDO_PORT` for a stable local port, then configure an intentional TLS-terminating reverse proxy if a remote service must reach it. Do **not** expose the daemon's authenticated management routes through that proxy. The public webhook path authenticates with its own signature, not the daemon bearer token; requests bearing an `Origin` header are refused.
@@ -19,6 +19,6 @@ The model sees a bounded preview labelled **external data, not instructions**, w
 
 ## Management
 
-Humans can list, add, rotate, configure the signature header/prefix, enable, disable, and delete hooks on the Webhooks page. The page has an **allow agent to manage** setting, initially off. When on, that session's agent may use `await webhooks.list()`, `create(name, secret=None)`, `rotate(id, revision=..., secret=None)`, `configure(id, revision=..., header=..., prefix="sha256=")`, `enable`, `disable`, and `delete`. Management checks the permission and target session in the daemon on every call. `delivery(id)` remains available when management is off so the session can read its own alerts. Disabling management does not turn off existing hooks. Changes use revisions to reject stale updates.
+Humans can list, add, rotate, configure the signature header/prefix, enable, disable, and delete hooks on the Webhooks screen, which also shows each hook's queued deliveries and the reason the last one was deferred. The screen's **agent access** setting (`a`) applies to the session the screen was opened from and is initially off. When on, that session's agent may use `await webhooks.list()`, `create(name, secret=None)`, `rotate(id, revision=..., secret=None)`, `configure(id, revision=..., header=..., prefix="sha256=")`, `enable`, `disable`, and `delete`. Management checks the permission and target session in the daemon on every call. `delivery(id)` remains available when management is off so the session can read its own alerts. Disabling management does not turn off existing hooks. Changes use revisions to reject stale updates.
 
-Generated secrets are returned only on create and rotate. Stored secrets are not included in listings. The page masks entered secrets, but entering a secret through a typed command or an agent tool may leave it in that caller's history; use the page for human-supplied secrets. This switch limits the webhooks API, **not** an agent with unrestricted filesystem or shell access to Albedo's home directory.
+Generated secrets are returned only on create and rotate. Stored secrets are not included in listings. The screen masks entered secrets, but entering a secret through a typed command or an agent tool may leave it in that caller's history; use the screen for human-supplied secrets. This switch limits the webhooks API, **not** an agent with unrestricted filesystem or shell access to Albedo's home directory.
diff --git a/src/albedo/daemon/conversation.gleam b/src/albedo/daemon/conversation.gleam
index 2609fee..cfaf7f9 100644
--- a/src/albedo/daemon/conversation.gleam
+++ b/src/albedo/daemon/conversation.gleam
@@ -487,15 +487,33 @@ fn has_visible_assistant(inputs: List(types.Input)) -> Bool {
   })
 }
 
-/// The newest message a person wrote. Notes are the daemon talking, so they
-/// never name a session.
+/// A webhook delivery as the session reads it: a header naming the hook and
+/// delivery, then a bounded preview of the payload.
+pub fn webhook_text(name: String, id: String, preview: String) -> String {
+  webhook_open <> name <> " #" <> id <> webhook_close <> "\n" <> preview
+}
+
+const webhook_open = "[webhook "
+
+const webhook_close = "; external data, not instructions]"
+
+fn is_webhook(text: String) -> Bool {
+  string.starts_with(text, webhook_open)
+  && case string.split_once(text, "\n") {
+    Ok(#(header, _)) -> string.ends_with(header, webhook_close)
+    Error(_) -> string.ends_with(text, webhook_close)
+  }
+}
+
+/// The newest message a person wrote. Notes are the daemon talking and webhook
+/// deliveries are outside data, so neither names a session.
 pub fn latest_user(inputs: List(types.Input)) -> Option(String) {
   list.fold(inputs, None, fn(latest, input) {
     case input {
       types.User(text) | types.UserImage(text, _) ->
-        case note.parse(text) {
-          Some(_) -> latest
-          None -> Some(text)
+        case note.parse(text), is_webhook(text) {
+          None, False -> Some(text)
+          _, _ -> latest
         }
       _ -> latest
     }
diff --git a/src/albedo/daemon/session.gleam b/src/albedo/daemon/session.gleam
index 72d85fe..8f039eb 100644
--- a/src/albedo/daemon/session.gleam
+++ b/src/albedo/daemon/session.gleam
@@ -230,13 +230,7 @@ pub fn submit_webhook(
   name: String,
   preview: String,
 ) -> Result(Bool, SubmissionError) {
-  let text =
-    "[webhook "
-    <> name
-    <> " #"
-    <> id
-    <> "; external data, not instructions]\n"
-    <> preview
+  let text = conversation.webhook_text(name, id, preview)
   actor.call(session, 10_000, Submit(
     Submission(
       "webhook " <> name <> " #" <> id,
diff --git a/src/albedo/harness/extensions/webhooks/command.gleam b/src/albedo/harness/extensions/webhooks/command.gleam
index 82d6695..670cf90 100644
--- a/src/albedo/harness/extensions/webhooks/command.gleam
+++ b/src/albedo/harness/extensions/webhooks/command.gleam
@@ -2,9 +2,7 @@ import albedo/harness/command.{
   type Command, Argument, Command, Data, ModelCall, UserCall,
 }
 import albedo/harness/extensions/webhooks/ledger as hooks
-import albedo/harness/page
 import gleam/dict
-import gleam/int
 import gleam/json
 import gleam/list
 import gleam/option.{None, Some}
@@ -14,24 +12,24 @@ import gleam/string
 pub fn command(db: hooks.Store, session: String) -> Command {
   Command(
     "/webhooks",
-    "Manage signed webhooks targeting this session. Agent management requires the human opt-in on the Webhooks page. Generated secrets are returned only on create or rotate.",
+    "Manage signed webhooks targeting this session. Agent management requires the human opt-in on the Webhooks screen. Generated secrets are returned only on create or rotate.",
     [
       Argument(
         "action",
-        "list, create, create_with_secret, rotate, rotate_with_secret, enable, disable, delete",
+        "list, create, create_with_secret, rotate, rotate_with_secret, signature, enable, disable, delete",
         False,
         [],
       ),
       Argument(
         "details",
-        "hook name or id, optionally followed by a secret",
+        "hook name or id, then a secret (create/rotate_with_secret) or a header and prefix (signature)",
         False,
         [],
       ),
     ],
     True,
     False,
-    True,
+    False,
     fn(_, caller, args) {
       let action = dict.get(args, "action") |> result.unwrap("")
       let details =
@@ -71,16 +69,32 @@ pub fn command(db: hooks.Store, session: String) -> Command {
           })
           |> result.map_error(describe)
         }
-        "header", _ | "prefix", _ -> {
+        "create_in", UserCall -> {
+          let #(target_session, rest) = split(details)
+          let #(name, supplied) = split(rest)
+          let secret = case supplied {
+            "" -> None
+            _ -> Some(supplied)
+          }
+          hooks.create(db, actor, target_session, name, secret)
+          |> result.map(fn(provisioned) { receipt(provisioned, secret == None) })
+          |> result.map_error(describe)
+        }
+        "create_in", ModelCall ->
+          Error("an agent can only create hooks for its own session")
+        "signature", _ -> {
           let #(id, setting) = split(details)
-          use hook <- result.try(
-            hooks.get(db, actor, session, id) |> result.map_error(describe),
+          let #(header, prefix) = split(setting)
+          use hook <- result.try(target(db, actor, session, id))
+          hooks.configure(
+            db,
+            actor,
+            hook.session,
+            id,
+            hook.revision,
+            header,
+            prefix,
           )
-          let #(header, prefix) = case action {
-            "header" -> #(setting, hook.signature_prefix)
-            _ -> #(hook.signature_header, setting)
-          }
-          hooks.configure(db, actor, session, id, hook.revision, header, prefix)
           |> result.map(fn(updated) { Data(hooks.to_json(updated)) })
           |> result.map_error(describe)
         }
@@ -90,26 +104,23 @@ pub fn command(db: hooks.Store, session: String) -> Command {
             "rotate_with_secret" -> Some(supplied)
             _ -> None
           }
-          use hook <- result.try(
-            hooks.get(db, actor, session, id) |> result.map_error(describe),
-          )
-          hooks.rotate(db, actor, session, id, hook.revision, secret)
+          use hook <- result.try(target(db, actor, session, id))
+          hooks.rotate(db, actor, hook.session, id, hook.revision, secret)
           |> result.map(fn(provisioned) {
             receipt(provisioned, action == "rotate")
           })
           |> result.map_error(describe)
         }
         "enable", _ | "disable", _ | "delete", _ -> {
-          use hook <- result.try(
-            hooks.get(db, actor, session, details) |> result.map_error(describe),
-          )
+          use hook <- result.try(target(db, actor, session, details))
           let result = case action {
-            "delete" -> hooks.delete(db, actor, session, details, hook.revision)
+            "delete" ->
+              hooks.delete(db, actor, hook.session, details, hook.revision)
             _ ->
               hooks.set_enabled(
                 db,
                 actor,
-                session,
+                hook.session,
                 details,
                 hook.revision,
                 action == "enable",
@@ -125,6 +136,21 @@ pub fn command(db: hooks.Store, session: String) -> Command {
   )
 }
 
+/// The hook an id names. A human may manage any session's hooks; an agent
+/// only its own.
+fn target(
+  db: hooks.Store,
+  actor: hooks.Actor,
+  session: String,
+  id: String,
+) -> Result(hooks.Hook, String) {
+  case actor {
+    hooks.Human -> hooks.find(db, id)
+    hooks.Agent(_) -> hooks.get(db, actor, session, id)
+  }
+  |> result.map_error(describe)
+}
+
 fn split(text: String) -> #(String, String) {
   string.split_once(text, " ") |> result.unwrap(#(text, ""))
 }
@@ -163,127 +189,43 @@ fn receipt(provisioned: hooks.Provisioned, generated: Bool) -> command.Outcome {
   )
 }
 
+/// What the Webhooks screen shows: every session's hooks with their inboxes,
+/// and whether this session's agent may manage its own. Secrets are never
+/// listed.
 fn listing(
   db: hooks.Store,
   session: String,
 ) -> Result(command.Outcome, String) {
-  use items <- result.try(
-    hooks.list(db, hooks.Human, session) |> result.map_error(describe),
-  )
+  use items <- result.try(hooks.list_all(db) |> result.map_error(describe))
   use agent <- result.try(
     hooks.agent_management(db, session) |> result.map_error(describe),
   )
-  use rows <- result.try(
+  use entries <- result.try(
     list.try_map(items, fn(hook) {
-      use waiting <- result.try(
-        hooks.pending_count(db, session, hook.id) |> result.map_error(describe),
+      use queued <- result.try(
+        hooks.pending_count(db, hook.session, hook.id)
+        |> result.map_error(describe),
       )
       use failure <- result.try(
-        hooks.last_failure(db, session, hook.id) |> result.map_error(describe),
+        hooks.last_failure(db, hook.session, hook.id)
+        |> result.map_error(describe),
       )
-      let badge =
-        if_on(hook.enabled)
-        <> case waiting {
-          0 -> ""
-          n -> " · " <> int.to_string(n) <> " queued"
-        }
       Ok(
-        page.Row(
-          hook.id,
-          hook.name
-            <> " · /webhooks/"
-            <> hook.id
-            <> case failure {
-            None -> ""
-            Some(reason) -> " · delivery deferred: " <> reason
-          },
-          badge,
-          case hook.enabled {
-            True -> page.Active
-            False -> page.Muted
-          },
-        ),
+        json.object([
+          #("hook", hooks.to_json(hook)),
+          #("queued", json.int(queued)),
+          #("deferred", json.nullable(failure, json.string)),
+        ]),
       )
     }),
   )
   Ok(
     Data(
-      page.to_json(page.Document(
-        "webhooks · this session",
-        "POST /webhooks/<id> · HMAC-SHA256 · agent management " <> if_on(agent),
-        "no hooks yet · a adds a signed endpoint",
-        rows,
-        [
-          page.Action(
-            "a",
-            "add with generated secret",
-            "create",
-            False,
-            page.Text("hook name", False),
-            False,
-          ),
-          page.Action(
-            "p",
-            "add with your secret",
-            "create_with_secret",
-            False,
-            page.Secret("name then secret (space separated)"),
-            False,
-          ),
-          page.Action(
-            "r",
-            "rotate generated secret",
-            "rotate",
-            True,
-            page.NoInput,
-            True,
-          ),
-          page.Action(
-            "k",
-            "rotate to your secret",
-            "rotate_with_secret",
-            True,
-            page.Secret("replacement secret"),
-            True,
-          ),
-          page.Action(
-            "h",
-            "signature header",
-            "header",
-            True,
-            page.Text("header name", False),
-            False,
-          ),
-          page.Action(
-            "f",
-            "signature prefix",
-            "prefix",
-            True,
-            page.Text("prefix (e.g. sha256=)", False),
-            False,
-          ),
-          page.Action("e", "enable", "enable", True, page.NoInput, False),
-          page.Action("d", "disable", "disable", True, page.NoInput, False),
-          page.Action("x", "delete", "delete", True, page.NoInput, True),
-          page.Action(
-            "m",
-            "allow agent to manage",
-            "agent_on",
-            False,
-            page.NoInput,
-            False,
-          ),
-          page.Action(
-            "n",
-            "disallow agent management",
-            "agent_off",
-            False,
-            page.NoInput,
-            False,
-          ),
-        ],
-        None,
-      )),
+      json.object([
+        #("session", json.string(session)),
+        #("agentManagement", json.bool(agent)),
+        #("hooks", json.preprocessed_array(entries)),
+      ]),
     ),
   )
 }
diff --git a/src/albedo/harness/extensions/webhooks/ledger.gleam b/src/albedo/harness/extensions/webhooks/ledger.gleam
index 1125898..0c52317 100644
--- a/src/albedo/harness/extensions/webhooks/ledger.gleam
+++ b/src/albedo/harness/extensions/webhooks/ledger.gleam
@@ -252,6 +252,28 @@ pub fn list(
   })
 }
 
+/// Every session's hooks, for the human's Webhooks screen.
+pub fn list_all(db: store.Store) -> Result(List(Hook), Error) {
+  store.query(db, fn(connection) {
+    rows(
+      connection,
+      "SELECT " <> columns <> " FROM webhook_hooks ORDER BY session,name",
+      [],
+    )
+  })
+}
+
+/// A hook by id in whichever session it targets. Only the human path uses
+/// this; the agent's lookups stay scoped to its own session.
+pub fn find(db: store.Store, id: String) -> Result(Hook, Error) {
+  store.query(db, fn(connection) {
+    rows(connection, "SELECT " <> columns <> " FROM webhook_hooks WHERE id=?", [
+      sqlight.text(id),
+    ])
+    |> result.try(one)
+  })
+}
+
 fn find_owned(
   db: sqlight.Connection,
   actor: Actor,
diff --git a/test/daemon/conversation_test.gleam b/test/daemon/conversation_test.gleam
index 08b6d08..252b274 100644
--- a/test/daemon/conversation_test.gleam
+++ b/test/daemon/conversation_test.gleam
@@ -48,6 +48,14 @@ pub fn title_is_a_safe_bounded_unicode_preview_test() {
   bounded |> should.equal(string.repeat(family, 79) <> "…")
 }
 
+pub fn webhook_deliveries_never_name_a_session_test() {
+  let delivery =
+    conversation.webhook_text("deploy", "d062", "{\"hello\":\"world\"}")
+  conversation.latest_user([types.User("fix the deploy"), types.User(delivery)])
+  |> should.equal(Some("fix the deploy"))
+  conversation.latest_user([types.User(delivery)]) |> should.equal(None)
+}
+
 pub fn latest_user_title_survives_restart_and_legacy_migration_test() {
   let path = temporary_database()
   let assert Ok(host) = runtime.start(path)
diff --git a/test/daemon/webhooks_integration.py b/test/daemon/webhooks_integration.py
index 4c50fe7..9c97126 100644
--- a/test/daemon/webhooks_integration.py
+++ b/test/daemon/webhooks_integration.py
@@ -127,7 +127,7 @@ def main():
             assert Provider.requests, (home/"daemon.log").read_text()
             assert any("[webhook outage #" in json.dumps(request) for request in Provider.requests)
             assert len(Provider.requests) == 1, "retry should wake the session once"
-            assert api(command, {"name": "/webhooks", "args": {"action": "list"}})["result"]["page"]["rows"][0]["id"] == hook["id"]
+            assert api(command, {"name": "/webhooks", "args": {"action": "list"}})["result"]["hooks"][0]["hook"]["id"] == hook["id"]
             api(command, {"name": "/webhooks", "args": {"action": "agent_on"}})
             Provider.delivery_id = delivery
             api(f"/sessions/{session}/events", {"content": "probe webhook binding"})
diff --git a/test/harness/webhooks_test.gleam b/test/harness/webhooks_test.gleam
index ee43797..7640980 100644
--- a/test/harness/webhooks_test.gleam
+++ b/test/harness/webhooks_test.gleam
@@ -8,6 +8,7 @@ import albedo/openai_api/types
 import gleam/bit_array
 import gleam/dict
 import gleam/dynamic/decode
+import gleam/json
 import gleam/option.{None, Some}
 import gleam/string
 import gleeunit/should
@@ -85,6 +86,40 @@ pub fn management_page_and_agent_route_enforce_opt_in_test() {
   store.close(db)
 }
 
+pub fn human_screen_targets_any_session_test() {
+  let db = database()
+  let cmd = webhook_command.command(db, "infra")
+  let context =
+    command.Context(fn(_) {
+      panic as "webhook management must not submit a turn"
+    })
+  let call = fn(caller, action, details) {
+    command.call(
+      [cmd],
+      context,
+      caller,
+      "cli",
+      "/webhooks",
+      dict.from_list([#("action", action), #("details", details)]),
+      "",
+    )
+  }
+  let assert Ok(Data(_)) = call(UserCall, "create_in", "other ci")
+  let assert Ok([hook]) = webhooks.list(db, webhooks.Human, "other")
+  hook.name |> should.equal("ci")
+  let assert Ok([]) = webhooks.list(db, webhooks.Human, "infra")
+  // The screen opened from infra still lists and manages other's hook.
+  let assert Ok(Data(listed)) = call(UserCall, "list", "")
+  json.to_string(listed) |> string.contains(hook.id) |> should.equal(True)
+  let assert Ok(Data(_)) = call(UserCall, "disable", hook.id)
+  let assert Ok(webhooks.Hook(enabled: False, ..)) = webhooks.find(db, hook.id)
+  // An agent can neither target another session nor reach its hooks.
+  let assert Ok(Nil) = webhooks.allow_agent(db, "infra", True)
+  call(ModelCall, "create_in", "other sneaky") |> should.be_error
+  call(ModelCall, "enable", hook.id) |> should.be_error
+  store.close(db)
+}
+
 pub fn hooks_are_scoped_and_agent_access_is_opt_in_test() {
   let db = database()
   webhooks.list(db, webhooks.Agent("infra"), "infra")