feat: add ETag cache optimization, code-split WebUI, and refactor XML tool scanner

- Chat history: early 304 via Revision()/DetailRevision() to avoid full snapshot reads
- WebUI: lazy-load tab containers with Suspense fallback
- Toolstream: split tool_sieve_xml.go into tags.go and scan.go
- CI: trigger on main branch, guard cross-build to dev/main pushes only
- Docs: add DEVELOPER.md developer quick reference

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

internal/chathistory/store.go

@@ -192,6 +192,18 @@ func (s *Store) Snapshot() (File, error) {
 	return cloneFile(s.state), nil
 }
 
+func (s *Store) Revision() (int64, error) {
+	if s == nil {
+		return 0, errors.New("chat history store is nil")
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.err != nil {
+		return 0, s.err
+	}
+	return s.state.Revision, nil
+}
+
 func (s *Store) Enabled() bool {
 	if s == nil {
 		return false
@@ -220,6 +232,22 @@ func (s *Store) Get(id string) (Entry, error) {
 	return cloneEntry(item), nil
 }
 
+func (s *Store) DetailRevision(id string) (int64, error) {
+	if s == nil {
+		return 0, errors.New("chat history store is nil")
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.err != nil {
+		return 0, s.err
+	}
+	item, ok := s.details[strings.TrimSpace(id)]
+	if !ok {
+		return 0, errors.New("chat history entry not found")
+	}
+	return item.Revision, nil
+}
+
 func (s *Store) Start(params StartParams) (Entry, error) {
 	if s == nil {
 		return Entry{}, errors.New("chat history store is nil")

internal/httpapi/admin/history/handler_chat_history.go

@@ -16,6 +16,24 @@ func (h *Handler) getChatHistory(w http.ResponseWriter, r *http.Request) {
 		writeJSON(w, http.StatusServiceUnavailable, map[string]any{"detail": "chat history store is not configured"})
 		return
 	}
+	ifNoneMatch := strings.TrimSpace(r.Header.Get("If-None-Match"))
+	if ifNoneMatch != "" {
+		revision, err := store.Revision()
+		if err != nil {
+			writeJSON(w, http.StatusServiceUnavailable, map[string]any{
+				"detail": err.Error(),
+				"path":   store.Path(),
+			})
+			return
+		}
+		etag := chathistory.ListETag(revision)
+		w.Header().Set("ETag", etag)
+		w.Header().Set("Cache-Control", "no-cache")
+		if ifNoneMatch == etag {
+			w.WriteHeader(http.StatusNotModified)
+			return
+		}
+	}
 	snapshot, err := store.Snapshot()
 	if err != nil {
 		writeJSON(w, http.StatusServiceUnavailable, map[string]any{
@@ -27,7 +45,7 @@ func (h *Handler) getChatHistory(w http.ResponseWriter, r *http.Request) {
 	etag := chathistory.ListETag(snapshot.Revision)
 	w.Header().Set("ETag", etag)
 	w.Header().Set("Cache-Control", "no-cache")
-	if strings.TrimSpace(r.Header.Get("If-None-Match")) == etag {
+	if ifNoneMatch == etag {
 		w.WriteHeader(http.StatusNotModified)
 		return
 	}
@@ -51,6 +69,25 @@ func (h *Handler) getChatHistoryItem(w http.ResponseWriter, r *http.Request) {
 		writeJSON(w, http.StatusBadRequest, map[string]any{"detail": "history id is required"})
 		return
 	}
+	ifNoneMatch := strings.TrimSpace(r.Header.Get("If-None-Match"))
+	if ifNoneMatch != "" {
+		revision, err := store.DetailRevision(id)
+		if err != nil {
+			status := http.StatusInternalServerError
+			if strings.Contains(strings.ToLower(err.Error()), "not found") {
+				status = http.StatusNotFound
+			}
+			writeJSON(w, status, map[string]any{"detail": err.Error()})
+			return
+		}
+		etag := chathistory.DetailETag(id, revision)
+		w.Header().Set("ETag", etag)
+		w.Header().Set("Cache-Control", "no-cache")
+		if ifNoneMatch == etag {
+			w.WriteHeader(http.StatusNotModified)
+			return
+		}
+	}
 	item, err := store.Get(id)
 	if err != nil {
 		status := http.StatusInternalServerError
@@ -63,7 +100,7 @@ func (h *Handler) getChatHistoryItem(w http.ResponseWriter, r *http.Request) {
 	etag := chathistory.DetailETag(item.ID, item.Revision)
 	w.Header().Set("ETag", etag)
 	w.Header().Set("Cache-Control", "no-cache")
-	if strings.TrimSpace(r.Header.Get("If-None-Match")) == etag {
+	if ifNoneMatch == etag {
 		w.WriteHeader(http.StatusNotModified)
 		return
 	}

internal/httpapi/admin/history/handler_chat_history_test.go

@@ -95,6 +95,15 @@ func TestGetChatHistoryAndUpdateSettings(t *testing.T) {
 		t.Fatalf("expected detail etag header")
 	}
 
+	notModifiedItemReq := httptest.NewRequest(http.MethodGet, "/chat-history/"+entry.ID, nil)
+	notModifiedItemReq.Header.Set("Authorization", "Bearer admin")
+	notModifiedItemReq.Header.Set("If-None-Match", itemRec.Header().Get("ETag"))
+	notModifiedItemRec := httptest.NewRecorder()
+	r.ServeHTTP(notModifiedItemRec, notModifiedItemReq)
+	if notModifiedItemRec.Code != http.StatusNotModified {
+		t.Fatalf("expected detail 304, got %d body=%s", notModifiedItemRec.Code, notModifiedItemRec.Body.String())
+	}
+
 	updateReq := httptest.NewRequest(http.MethodPut, "/chat-history/settings", bytes.NewReader([]byte(`{"limit":10}`)))
 	updateReq.Header.Set("Authorization", "Bearer admin")
 	updateRec := httptest.NewRecorder()

internal/toolstream/tool_sieve_xml.go

@@ -2,50 +2,9 @@ package toolstream
 
 import (
 	"ds2api/internal/toolcall"
-	"regexp"
 	"strings"
 )
 
-// --- XML tool call support for the streaming sieve ---
-
-//nolint:unused // kept as explicit tag inventory for future XML sieve refinements.
-var xmlToolCallClosingTags = []string{"</tool_calls>", "</|dsml|tool_calls>", "</dsml|tool_calls>", "</｜tool_calls>", "</|tool_calls>"}
-var xmlToolCallOpeningTags = []string{
-	"<tool_calls", "<invoke",
-	"<|dsml|tool_calls", "<|dsml|invoke",
-	"<dsml|tool_calls", "<dsml|invoke",
-	"<｜tool_calls", "<｜invoke",
-	"<|tool_calls", "<|invoke",
-}
-
-// xmlToolCallTagPairs maps each opening tag to its expected closing tag.
-// Order matters: longer/wrapper tags must be checked first.
-var xmlToolCallTagPairs = []struct{ open, close string }{
-	{"<|dsml|tool_calls", "</|dsml|tool_calls>"},
-	{"<dsml|tool_calls", "</dsml|tool_calls>"},
-	{"<｜tool_calls", "</｜tool_calls>"},
-	{"<|tool_calls", "</|tool_calls>"},
-	{"<tool_calls", "</tool_calls>"},
-}
-
-// xmlToolCallBlockPattern matches a complete canonical XML tool call block.
-//
-//nolint:unused // reserved for future fast-path XML block detection.
-var xmlToolCallBlockPattern = regexp.MustCompile(`(?is)((?:<tool_calls\b|<\|dsml\|tool_calls\b)[^>]*>\s*(?:.*?)\s*(?:</tool_calls>|</\|dsml\|tool_calls>))`)
-
-// xmlToolTagsToDetect is the set of XML tag prefixes used by findToolSegmentStart.
-var xmlToolTagsToDetect = []string{
-	"<|dsml|tool_calls>", "<|dsml|tool_calls\n", "<|dsml|tool_calls ",
-	"<|dsml|invoke ", "<|dsml|invoke\n", "<|dsml|invoke\t", "<|dsml|invoke\r",
-	"<dsml|tool_calls>", "<dsml|tool_calls\n", "<dsml|tool_calls ",
-	"<dsml|invoke ", "<dsml|invoke\n", "<dsml|invoke\t", "<dsml|invoke\r",
-	"<｜tool_calls>", "<｜tool_calls\n", "<｜tool_calls ",
-	"<｜invoke ", "<｜invoke\n", "<｜invoke\t", "<｜invoke\r",
-	"<|tool_calls>", "<|tool_calls\n", "<|tool_calls ",
-	"<|invoke ", "<|invoke\n", "<|invoke\t", "<|invoke\r",
-	"<tool_calls>", "<tool_calls\n", "<tool_calls ", "<invoke ", "<invoke\n", "<invoke\t", "<invoke\r",
-}
-
 // consumeXMLToolCapture tries to extract complete XML tool call blocks from captured text.
 func consumeXMLToolCapture(captured string, toolNames []string) (prefix string, calls []toolcall.ParsedToolCall, suffix string, ready bool) {
 	lower := strings.ToLower(captured)
@@ -137,88 +96,6 @@ func consumeXMLToolCapture(captured string, toolNames []string) (prefix string,
 	return "", nil, "", false
 }
 
-func findMatchingXMLToolWrapperClose(s, openTag, closeTag string, openIdx int) int {
-	if s == "" || openTag == "" || closeTag == "" || openIdx < 0 {
-		return -1
-	}
-	lower := strings.ToLower(s)
-	openTarget := strings.ToLower(openTag)
-	closeTarget := strings.ToLower(closeTag)
-	depth := 1
-	for i := openIdx + len(openTarget); i < len(s); {
-		switch {
-		case strings.HasPrefix(lower[i:], "<![cdata["):
-			end := strings.Index(lower[i+len("<![cdata["):], "]]>")
-			if end < 0 {
-				return -1
-			}
-			i += len("<![cdata[") + end + len("]]>")
-		case strings.HasPrefix(lower[i:], "<!--"):
-			end := strings.Index(lower[i+len("<!--"):], "-->")
-			if end < 0 {
-				return -1
-			}
-			i += len("<!--") + end + len("-->")
-		case strings.HasPrefix(lower[i:], closeTarget):
-			depth--
-			if depth == 0 {
-				return i
-			}
-			i += len(closeTarget)
-		case strings.HasPrefix(lower[i:], openTarget) && hasXMLToolTagBoundary(s, i+len(openTarget)):
-			depth++
-			i += len(openTarget)
-		default:
-			i++
-		}
-	}
-	return -1
-}
-
-func findXMLOpenOutsideCDATA(s, openTag string, start int) int {
-	if s == "" || openTag == "" {
-		return -1
-	}
-	if start < 0 {
-		start = 0
-	}
-	lower := strings.ToLower(s)
-	target := strings.ToLower(openTag)
-	for i := start; i < len(s); {
-		switch {
-		case strings.HasPrefix(lower[i:], "<![cdata["):
-			end := strings.Index(lower[i+len("<![cdata["):], "]]>")
-			if end < 0 {
-				return -1
-			}
-			i += len("<![cdata[") + end + len("]]>")
-		case strings.HasPrefix(lower[i:], "<!--"):
-			end := strings.Index(lower[i+len("<!--"):], "-->")
-			if end < 0 {
-				return -1
-			}
-			i += len("<!--") + end + len("-->")
-		case strings.HasPrefix(lower[i:], target) && hasXMLToolTagBoundary(s, i+len(target)):
-			return i
-		default:
-			i++
-		}
-	}
-	return -1
-}
-
-func hasXMLToolTagBoundary(text string, idx int) bool {
-	if idx >= len(text) {
-		return true
-	}
-	switch text[idx] {
-	case ' ', '\t', '\n', '\r', '>', '/':
-		return true
-	default:
-		return false
-	}
-}
-
 // hasOpenXMLToolTag returns true if captured text contains an XML tool opening tag
 // whose SPECIFIC closing tag has not appeared yet.
 func hasOpenXMLToolTag(captured string) bool {
@@ -307,59 +184,6 @@ func firstInvokeIndex(lower string) (int, bool) {
 	}
 }
 
-func findXMLCloseOutsideCDATA(s, closeTag string, start int) int {
-	if s == "" || closeTag == "" {
-		return -1
-	}
-	if start < 0 {
-		start = 0
-	}
-	lower := strings.ToLower(s)
-	target := strings.ToLower(closeTag)
-	for i := start; i < len(s); {
-		switch {
-		case strings.HasPrefix(lower[i:], "<![cdata["):
-			end := strings.Index(lower[i+len("<![cdata["):], "]]>")
-			if end < 0 {
-				return -1
-			}
-			i += len("<![cdata[") + end + len("]]>")
-		case strings.HasPrefix(lower[i:], "<!--"):
-			end := strings.Index(lower[i+len("<!--"):], "-->")
-			if end < 0 {
-				return -1
-			}
-			i += len("<!--") + end + len("-->")
-		case strings.HasPrefix(lower[i:], target):
-			return i
-		default:
-			i++
-		}
-	}
-	return -1
-}
-
-func findXMLTagEnd(s string, start int) int {
-	quote := byte(0)
-	for i := start; i < len(s); i++ {
-		ch := s[i]
-		if quote != 0 {
-			if ch == quote {
-				quote = 0
-			}
-			continue
-		}
-		if ch == '"' || ch == '\'' {
-			quote = ch
-			continue
-		}
-		if ch == '>' {
-			return i
-		}
-	}
-	return -1
-}
-
 // findPartialXMLToolTagStart checks if the string ends with a partial canonical
 // XML wrapper tag (e.g., "<too") and returns the position of the '<'.
 func findPartialXMLToolTagStart(s string) int {

internal/toolstream/tool_sieve_xml_scan.go

@@ -0,0 +1,138 @@
+package toolstream
+
+import "strings"
+
+func findMatchingXMLToolWrapperClose(s, openTag, closeTag string, openIdx int) int {
+	if s == "" || openTag == "" || closeTag == "" || openIdx < 0 {
+		return -1
+	}
+	lower := strings.ToLower(s)
+	openTarget := strings.ToLower(openTag)
+	closeTarget := strings.ToLower(closeTag)
+	depth := 1
+	for i := openIdx + len(openTarget); i < len(s); {
+		switch {
+		case strings.HasPrefix(lower[i:], "<![cdata["):
+			end := strings.Index(lower[i+len("<![cdata["):], "]]>")
+			if end < 0 {
+				return -1
+			}
+			i += len("<![cdata[") + end + len("]]>")
+		case strings.HasPrefix(lower[i:], "<!--"):
+			end := strings.Index(lower[i+len("<!--"):], "-->")
+			if end < 0 {
+				return -1
+			}
+			i += len("<!--") + end + len("-->")
+		case strings.HasPrefix(lower[i:], closeTarget):
+			depth--
+			if depth == 0 {
+				return i
+			}
+			i += len(closeTarget)
+		case strings.HasPrefix(lower[i:], openTarget) && hasXMLToolTagBoundary(s, i+len(openTarget)):
+			depth++
+			i += len(openTarget)
+		default:
+			i++
+		}
+	}
+	return -1
+}
+
+func findXMLOpenOutsideCDATA(s, openTag string, start int) int {
+	if s == "" || openTag == "" {
+		return -1
+	}
+	if start < 0 {
+		start = 0
+	}
+	lower := strings.ToLower(s)
+	target := strings.ToLower(openTag)
+	for i := start; i < len(s); {
+		switch {
+		case strings.HasPrefix(lower[i:], "<![cdata["):
+			end := strings.Index(lower[i+len("<![cdata["):], "]]>")
+			if end < 0 {
+				return -1
+			}
+			i += len("<![cdata[") + end + len("]]>")
+		case strings.HasPrefix(lower[i:], "<!--"):
+			end := strings.Index(lower[i+len("<!--"):], "-->")
+			if end < 0 {
+				return -1
+			}
+			i += len("<!--") + end + len("-->")
+		case strings.HasPrefix(lower[i:], target) && hasXMLToolTagBoundary(s, i+len(target)):
+			return i
+		default:
+			i++
+		}
+	}
+	return -1
+}
+
+func findXMLCloseOutsideCDATA(s, closeTag string, start int) int {
+	if s == "" || closeTag == "" {
+		return -1
+	}
+	if start < 0 {
+		start = 0
+	}
+	lower := strings.ToLower(s)
+	target := strings.ToLower(closeTag)
+	for i := start; i < len(s); {
+		switch {
+		case strings.HasPrefix(lower[i:], "<![cdata["):
+			end := strings.Index(lower[i+len("<![cdata["):], "]]>")
+			if end < 0 {
+				return -1
+			}
+			i += len("<![cdata[") + end + len("]]>")
+		case strings.HasPrefix(lower[i:], "<!--"):
+			end := strings.Index(lower[i+len("<!--"):], "-->")
+			if end < 0 {
+				return -1
+			}
+			i += len("<!--") + end + len("-->")
+		case strings.HasPrefix(lower[i:], target):
+			return i
+		default:
+			i++
+		}
+	}
+	return -1
+}
+
+func hasXMLToolTagBoundary(text string, idx int) bool {
+	if idx >= len(text) {
+		return true
+	}
+	switch text[idx] {
+	case ' ', '\t', '\n', '\r', '>', '/':
+		return true
+	default:
+		return false
+	}
+}
+
+func findXMLTagEnd(s string, start int) int {
+	quote := byte(0)
+	for i := start; i < len(s); i++ {
+		ch := s[i]
+		if quote != 0 {
+			if ch == quote {
+				quote = 0
+			}
+			continue
+		}
+		if ch == '"' || ch == '\'' {
+			quote = ch
+			continue
+		}
+		if ch == '>' {
+			return i
+		}
+	}
+	return -1
+}

internal/toolstream/tool_sieve_xml_tags.go

@@ -0,0 +1,43 @@
+package toolstream
+
+import "regexp"
+
+// --- XML tool call support for the streaming sieve ---
+
+//nolint:unused // kept as explicit tag inventory for future XML sieve refinements.
+var xmlToolCallClosingTags = []string{"</tool_calls>", "</|dsml|tool_calls>", "</dsml|tool_calls>", "</｜tool_calls>", "</|tool_calls>"}
+var xmlToolCallOpeningTags = []string{
+	"<tool_calls", "<invoke",
+	"<|dsml|tool_calls", "<|dsml|invoke",
+	"<dsml|tool_calls", "<dsml|invoke",
+	"<｜tool_calls", "<｜invoke",
+	"<|tool_calls", "<|invoke",
+}
+
+// xmlToolCallTagPairs maps each opening tag to its expected closing tag.
+// Order matters: longer/wrapper tags must be checked first.
+var xmlToolCallTagPairs = []struct{ open, close string }{
+	{"<|dsml|tool_calls", "</|dsml|tool_calls>"},
+	{"<dsml|tool_calls", "</dsml|tool_calls>"},
+	{"<｜tool_calls", "</｜tool_calls>"},
+	{"<|tool_calls", "</|tool_calls>"},
+	{"<tool_calls", "</tool_calls>"},
+}
+
+// xmlToolCallBlockPattern matches a complete canonical XML tool call block.
+//
+//nolint:unused // reserved for future fast-path XML block detection.
+var xmlToolCallBlockPattern = regexp.MustCompile(`(?is)((?:<tool_calls\b|<\|dsml\|tool_calls\b)[^>]*>\s*(?:.*?)\s*(?:</tool_calls>|</\|dsml\|tool_calls>))`)
+
+// xmlToolTagsToDetect is the set of XML tag prefixes used by findToolSegmentStart.
+var xmlToolTagsToDetect = []string{
+	"<|dsml|tool_calls>", "<|dsml|tool_calls\n", "<|dsml|tool_calls ",
+	"<|dsml|invoke ", "<|dsml|invoke\n", "<|dsml|invoke\t", "<|dsml|invoke\r",
+	"<dsml|tool_calls>", "<dsml|tool_calls\n", "<dsml|tool_calls ",
+	"<dsml|invoke ", "<dsml|invoke\n", "<dsml|invoke\t", "<dsml|invoke\r",
+	"<｜tool_calls>", "<｜tool_calls\n", "<｜tool_calls ",
+	"<｜invoke ", "<｜invoke\n", "<｜invoke\t", "<｜invoke\r",
+	"<|tool_calls>", "<|tool_calls\n", "<|tool_calls ",
+	"<|invoke ", "<|invoke\n", "<|invoke\t", "<|invoke\r",
+	"<tool_calls>", "<tool_calls\n", "<tool_calls ", "<invoke ", "<invoke\n", "<invoke\t", "<invoke\r",
+}