feat(adminapi): session dividers + longer display history

The Chat tab now loads up to 200 rows and renders horizontal divider
lines between sessions (from /clear or the 4-hour idle break). Old
image attachments from previous turns are rendered inline as <img>
tags in the bubble so multimodal conversations are visible on page
reload.

- store: DisplayableStore interface with DisplayHistory(chatID, limit)
  returning HistoryItem rows. is_reset rows surface as role="break";
  image_url parts are extracted into HistoryItem.ImageURLs.
- agent: GetDisplayHistory wrapper with fallback to plain GetHistory
  for the in-memory store.
- template: chat-break divider (horizontal line + date pill) rendered
  between message groups. Break reason humanised (CONTEXT_RESET →
  "Cleared", IDLE_4H → "4h idle"). Bubble meta now includes the
  message timestamp.

Author: Alexey Panfilov

.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"6cecbd7a-9522-431a-98ae-17f6056c37eb","pid":13602,"acquiredAt":1776707251721}

internal/adminapi/chat.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"telegram-agent/internal/llm"
+	"telegram-agent/internal/store"
 )
 
 // defaultAdminChatID is used when no forward-auth user is present (local dev
@@ -22,6 +23,7 @@ type ChatAgent interface {
 	Process(ctx context.Context, chatID int64, userMsg llm.Message, onToolCall func(string)) (string, error)
 	ProcessStream(ctx context.Context, chatID int64, userMsg llm.Message, onToolCall func(string), onChunk func(string)) (string, error)
 	GetChatHistory(chatID int64) []llm.Message
+	GetDisplayHistory(chatID int64, limit int) []store.HistoryItem
 	ClearChatHistory(chatID int64)
 	PopLastUserTurn(chatID int64) (string, bool)
 }
@@ -67,24 +69,44 @@ func routedModel(r interface {
 }
 
 type chatMsgView struct {
-	Role string // "user" or "assistant"
-	Body string
+	Role      string   // "user" | "assistant" | "break"
+	Body      string   // message text or break reason
+	ImageURLs []string // image_url parts rendered as <img> in the bubble
+	Time      string   // HH:MM for bubble, date for break markers
+	BreakDate string   // full "2006-01-02 15:04" for dividers
 }
 
 type chatData struct {
 	ActiveTab string
 	History   []chatMsgView
 }
 
+// displayHistoryLimit is how many rows the Chat page loads on open. Larger
+// than the LLM context window — this is purely for UI scrollback, not
+// context. Capped to keep renders quick on slow connections.
+const displayHistoryLimit = 200
+
 func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
 	data := chatData{ActiveTab: "chat"}
 	if s.agent != nil {
 		chatID := s.chatIDFor(r)
-		for _, m := range s.agent.GetChatHistory(chatID) {
-			if m.Role != "user" && m.Role != "assistant" {
+		for _, it := range s.agent.GetDisplayHistory(chatID, displayHistoryLimit) {
+			v := chatMsgView{Role: it.Role, Body: it.Content, ImageURLs: it.ImageURLs}
+			if it.Role == "break" {
+				v.BreakDate = it.CreatedAt.Local().Format("2006-01-02 15:04")
+				v.Body = humanizeBreakReason(it.Content)
+			} else if !it.CreatedAt.IsZero() {
+				v.Time = it.CreatedAt.Local().Format("15:04")
+			}
+			// Skip tool-role rows and empty assistant tool-call placeholders —
+			// they'd just be visual noise in a human-facing view.
+			if it.Role == "tool" {
+				continue
+			}
+			if it.Role == "assistant" && v.Body == "" && len(v.ImageURLs) == 0 {
 				continue
 			}
-			data.History = append(data.History, chatMsgView{Role: m.Role, Body: m.Content})
+			data.History = append(data.History, v)
 		}
 	}
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
@@ -264,6 +286,22 @@ func (s *Server) handleChatClear(w http.ResponseWriter, r *http.Request) {
 	_, _ = w.Write([]byte(`<div id="chat-messages" class="chat-messages"></div>`))
 }
 
+// humanizeBreakReason turns the internal session-break reason string into a
+// short label for the UI divider. Unknown reasons fall through verbatim so
+// future break types remain visible without a code change.
+func humanizeBreakReason(raw string) string {
+	switch raw {
+	case "CONTEXT_RESET":
+		return "Cleared"
+	case "IDLE_4H":
+		return "4h idle"
+	case "":
+		return ""
+	default:
+		return raw
+	}
+}
+
 // buildUserMessage packs text + any attached images into an llm.Message.
 // When images are present we build a multimodal Parts payload; otherwise
 // we stick with plain Content so non-vision providers see a simple string.

internal/adminapi/templates/chat.html

@@ -66,6 +66,13 @@
 
     /* Drag-over visual cue on the whole chat wrap. */
     .chat-wrap.drop-active { outline: 2px dashed var(--accent, #3b82f6); outline-offset: -4px; }
+
+    /* Session break divider — rendered between groups of messages separated
+       by /clear or the 4-hour idle reset. Flat horizontal line with a small
+       date pill centred on it. */
+    .chat-break { display: flex; align-items: center; gap: 0.6rem; margin: 0.75rem 0.25rem; opacity: 0.65; align-self: stretch; }
+    .chat-break::before, .chat-break::after { content: ''; flex: 1; height: 1px; background: rgba(0,0,0,0.15); }
+    .chat-break__label { font-size: 0.72em; padding: 0.1em 0.6em; border-radius: 999px; background: rgba(0,0,0,0.06); white-space: nowrap; }
   </style>
 </head>
 <body>
@@ -80,14 +87,26 @@ <h1>Admin</h1>
 
     <div id="chat-messages" class="chat-messages">
       {{range .History}}
-      <div class="chat-msg chat-msg--{{.Role}}">
-        <div class="chat-msg__meta">{{if eq .Role "user"}}You{{else}}Assistant{{end}}</div>
-        {{if eq .Role "assistant"}}
-        <div class="chat-msg__body md" data-md="{{.Body}}"></div>
+        {{if eq .Role "break"}}
+          <div class="chat-break"><span class="chat-break__label">{{.BreakDate}}{{if .Body}} &middot; {{.Body}}{{end}}</span></div>
         {{else}}
-        <div class="chat-msg__body">{{.Body}}</div>
+          <div class="chat-msg chat-msg--{{.Role}}">
+            <div class="chat-msg__meta">
+              {{if eq .Role "user"}}You{{else}}Assistant{{end}}
+              {{if .Time}} &middot; {{.Time}}{{end}}
+            </div>
+            {{if .ImageURLs}}
+              <div class="chat-msg__body">
+                {{range .ImageURLs}}<img src="{{.}}" alt="attachment">{{end}}
+                {{if .Body}}<div>{{.Body}}</div>{{end}}
+              </div>
+            {{else if eq .Role "assistant"}}
+              <div class="chat-msg__body md" data-md="{{.Body}}"></div>
+            {{else}}
+              <div class="chat-msg__body">{{.Body}}</div>
+            {{end}}
+          </div>
         {{end}}
-      </div>
       {{end}}
     </div>
 

internal/agent/agent.go

@@ -120,6 +120,24 @@ func (a *Agent) GetChatHistory(chatID int64) []llm.Message {
 	return a.store.GetHistory(chatID)
 }
 
+// GetDisplayHistory returns UI-oriented history including session-break
+// markers and image attachment URLs. Falls back to plain GetHistory when
+// the backing store doesn't implement DisplayableStore. `limit` caps the
+// number of rows fetched; pass 0 for the store default.
+func (a *Agent) GetDisplayHistory(chatID int64, limit int) []store.HistoryItem {
+	if ds, ok := a.store.(store.DisplayableStore); ok {
+		return ds.DisplayHistory(chatID, limit)
+	}
+	out := make([]store.HistoryItem, 0)
+	for _, m := range a.store.GetHistory(chatID) {
+		if m.Role != "user" && m.Role != "assistant" {
+			continue
+		}
+		out = append(out, store.HistoryItem{Role: m.Role, Content: m.Content})
+	}
+	return out
+}
+
 // ClearChatHistory resets the conversation for the given chat ID.
 func (a *Agent) ClearChatHistory(chatID int64) {
 	a.store.ClearHistory(chatID)

internal/store/postgres.go

@@ -398,6 +398,71 @@ func (p *Postgres) ClearHistory(chatID int64) {
 	p.pool.Exec(ctx, `INSERT INTO messages (chat_id, role, content, is_reset) VALUES ($1, 'system', 'CONTEXT_RESET', TRUE)`, chatID) //nolint:errcheck
 }
 
+// DisplayHistory returns the last `limit` non-compacted rows including
+// is_reset session-break markers. Used by the admin web UI to show the
+// full recent conversation with dividers between sessions.
+func (p *Postgres) DisplayHistory(chatID int64, limit int) []HistoryItem {
+	if limit <= 0 {
+		limit = 200
+	}
+	ctx := context.Background()
+	rows, err := p.pool.Query(ctx, `
+		SELECT role, content, parts, is_reset, created_at
+		FROM messages
+		WHERE chat_id = $1 AND is_compacted = FALSE
+		ORDER BY id DESC LIMIT $2`,
+		chatID, limit)
+	if err != nil {
+		return nil
+	}
+	defer rows.Close()
+
+	var out []HistoryItem
+	for rows.Next() {
+		var role, content string
+		var partsJSON *string
+		var isReset bool
+		var createdAt time.Time
+		if err := rows.Scan(&role, &content, &partsJSON, &isReset, &createdAt); err != nil {
+			continue
+		}
+		item := HistoryItem{Content: content, CreatedAt: createdAt}
+		if isReset {
+			item.Role = "break"
+			out = append(out, item)
+			continue
+		}
+		item.Role = role
+		if partsJSON != nil && *partsJSON != "" {
+			var parts []llm.ContentPart
+			if err := json.Unmarshal([]byte(*partsJSON), &parts); err == nil {
+				var textBuf strings.Builder
+				for _, pt := range parts {
+					switch pt.Type {
+					case "text":
+						if textBuf.Len() > 0 {
+							textBuf.WriteByte('\n')
+						}
+						textBuf.WriteString(pt.Text)
+					case "image_url":
+						if pt.ImageURL != nil && pt.ImageURL.URL != "" {
+							item.ImageURLs = append(item.ImageURLs, pt.ImageURL.URL)
+						}
+					}
+				}
+				if content == "" {
+					item.Content = textBuf.String()
+				}
+			}
+		}
+		out = append(out, item)
+	}
+	for i, j := 0, len(out)-1; i < j; i, j = i+1, j-1 {
+		out[i], out[j] = out[j], out[i]
+	}
+	return out
+}
+
 // LastUserMessage returns the most recent user-role row within the current
 // session (id > last reset). Used by admin chat for Regenerate / Edit.
 func (p *Postgres) LastUserMessage(chatID int64) (int64, string, bool) {

internal/store/sqlite.go

@@ -304,6 +304,73 @@ func (s *SQLite) ClearHistory(chatID int64) {
 	s.db.Exec(`INSERT INTO messages (chat_id, role, content, is_reset) VALUES (?, 'system', 'CONTEXT_RESET', 1)`, chatID) //nolint:errcheck
 }
 
+// DisplayHistory returns the last `limit` non-compacted rows including
+// is_reset session-break markers. Used by the admin web UI to show the
+// full recent conversation with dividers between sessions.
+func (s *SQLite) DisplayHistory(chatID int64, limit int) []HistoryItem {
+	if limit <= 0 {
+		limit = 200
+	}
+	rows, err := s.db.Query(`
+		SELECT role, content, parts, is_reset, created_at
+		FROM messages
+		WHERE chat_id = ? AND is_compacted = 0
+		ORDER BY id DESC LIMIT ?`,
+		chatID, limit)
+	if err != nil {
+		return nil
+	}
+	defer rows.Close()
+
+	var out []HistoryItem
+	for rows.Next() {
+		var role, content string
+		var partsJSON sql.NullString
+		var isReset int
+		var createdAt time.Time
+		if err := rows.Scan(&role, &content, &partsJSON, &isReset, &createdAt); err != nil {
+			continue
+		}
+		item := HistoryItem{Content: content, CreatedAt: createdAt}
+		if isReset == 1 {
+			item.Role = "break"
+			out = append(out, item)
+			continue
+		}
+		item.Role = role
+		if partsJSON.Valid && partsJSON.String != "" {
+			var parts []llm.ContentPart
+			if err := json.Unmarshal([]byte(partsJSON.String), &parts); err == nil {
+				// Collapse parts into display content: text parts concatenated,
+				// image URLs surfaced separately so the template can render them.
+				var textBuf strings.Builder
+				for _, p := range parts {
+					switch p.Type {
+					case "text":
+						if textBuf.Len() > 0 {
+							textBuf.WriteByte('\n')
+						}
+						textBuf.WriteString(p.Text)
+					case "image_url":
+						if p.ImageURL != nil && p.ImageURL.URL != "" {
+							item.ImageURLs = append(item.ImageURLs, p.ImageURL.URL)
+						}
+					}
+				}
+				if content == "" {
+					item.Content = textBuf.String()
+				}
+			}
+		}
+		out = append(out, item)
+	}
+	// DESC → chronological.
+	for i, j := 0, len(out)-1; i < j; i, j = i+1, j-1 {
+		out[i], out[j] = out[j], out[i]
+	}
+	return out
+}
+
 // LastUserMessage returns the most recent user-role row within the current
 // session (id > last reset). Used by admin chat for Regenerate / Edit.
 func (s *SQLite) LastUserMessage(chatID int64) (int64, string, bool) {

internal/store/store.go

@@ -47,6 +47,25 @@ type HistorySnippet struct {
 	BotText   string
 }
 
+// HistoryItem is one row returned by DisplayableStore.DisplayHistory — a
+// message, an image attachment descriptor, or a session-break marker. The
+// admin web UI uses this to render the conversation with <hr/>-style
+// dividers between sessions (from /clear or the 4-hour idle break).
+type HistoryItem struct {
+	Role      string    // "user" | "assistant" | "tool" | "break"
+	Content   string    // message text OR break reason
+	ImageURLs []string  // image_url parts (data URIs or http links)
+	CreatedAt time.Time // for display timestamps + divider labels
+}
+
+// DisplayableStore extends Store with a UI-oriented history fetch that
+// includes session-break markers and surfaces image attachments.
+// Implemented by SQLite and Postgres; the in-memory store skips it.
+type DisplayableStore interface {
+	Store
+	DisplayHistory(chatID int64, limit int) []HistoryItem
+}
+
 // TruncatableStore supports dropping the tail of a conversation. Used by the
 // admin web chat to implement Regenerate / Edit. LastUserMessage returns the
 // most recent user-role row within the current session (id > last reset).