Files
alan 1a9db0206c Chat: group consecutive background-task notices into one collapsed chip
Two or more consecutive Claude Code task notices fold into one
task_notices row: a chip 'N background tasks' (tinted when one failed)
that opens a sheet with one compact row per task (outcome icon, summary,
outcome word), like the tools and permissions chips. A lone notice stays
one line. The server also treats Claude Code's [SYSTEM NOTIFICATION]
banner as harness text, so a bannered notification without an origin is
still a notice, never the operator's turn. The chat fixture gains
?tasks=N.
2026-11-03 12:44:57 +00:00

283 lines
9.3 KiB
Go

package claude
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"regexp"
"strings"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// Claude Code delivers more than the operator's prompts as user-role input:
// subagent and peer-session reports, background-task notifications, system
// reminders, skill bodies and mid-turn message wrappers. This file decides
// which of those is the operator's own turn and which is harness content, so
// neither history nor the live stream draws harness text as the operator's.
// injectedOrigin is the CLI's record of where a user-role entry came from. It is
// set on peer reports ({"kind":"peer", ...}) and task notifications
// ({"kind":"task-notification"}); an operator prompt carries none.
type injectedOrigin struct {
Kind string `json:"kind"`
From string `json:"from"`
Name string `json:"name"`
Handback bool `json:"handback"`
HandbackReportText string `json:"handbackReportText"`
}
func decodeOrigin(raw json.RawMessage) injectedOrigin {
var origin injectedOrigin
if len(raw) > 0 && raw[0] == '{' {
_ = json.Unmarshal(raw, &origin)
}
return origin
}
// injectedClass is how one user-role text is shown.
type injectedClass int
const (
// classOperator is the operator's own turn; text is what they wrote (any
// harness wrapper around it removed).
classOperator injectedClass = iota
classAgentReport
classNotice
// classHidden is harness-internal content that is not shown at all.
classHidden
)
type injected struct {
class injectedClass
// id is a stable identity derived from the content, so the live frame and
// the history entry for the same delivery are one message. Empty for an
// operator turn, which keeps its own identity.
id string
text string
sender string
}
var (
agentMessageOpen = regexp.MustCompile(`<agent-message(?:\s+from="([^"]*)")?[^>]*>`)
taskIDPattern = regexp.MustCompile(`<task-id>\s*([^<\s]+)\s*</task-id>`)
taskStatusPattern = regexp.MustCompile(`<status>\s*([^<]*?)\s*</status>`)
midTurnWrapper = "The user sent a new message while you were working:"
midTurnWrapperTail = "\n\nThis is how Claude Code surfaces messages"
peerSessionPreamble = "Another Claude session sent a message:"
handbackMarker = "The report follows:"
)
// harnessPrefixes open user-role text that Claude Code wrote, never the
// operator: reminders, slash-command plumbing, interrupt markers and the
// placeholder lines it records beside pasted images and loaded skills.
var harnessPrefixes = []string{
"<system-reminder>",
"<local-command-",
"<command-name>",
"<command-message>",
"<user-prompt-submit-hook>",
"Caveat: The messages below were generated by the user while running local commands.",
"[Request interrupted by user",
"Base directory for this skill:",
// The banner Claude Code puts before a background-task event it delivers
// as user-role text (current CLIs; older ones sent the bare block).
"[SYSTEM NOTIFICATION - NOT USER INPUT]",
}
// classifyInjected decides how a user-role text is shown. origin and meta are
// the CLI's own markers (origin object, isMeta flag); the text shape is the
// fallback for a line that does not carry them.
func classifyInjected(text string, origin injectedOrigin, meta bool) injected {
trimmed := strings.TrimSpace(text)
if origin.Kind == "peer" || startsAgentMessage(trimmed) {
return agentReport(trimmed, origin)
}
if origin.Kind == "task-notification" || strings.Contains(trimmed, "<task-notification>") && startsHarness(trimmed) {
if notice, ok := taskNotice(trimmed); ok {
return notice
}
return injected{class: classHidden}
}
if operator, ok := unwrapMidTurn(trimmed); ok {
return injected{class: classOperator, text: operator}
}
if meta || startsHarness(trimmed) {
return injected{class: classHidden}
}
return injected{class: classOperator, text: text}
}
func startsAgentMessage(text string) bool {
text = strings.TrimSpace(strings.TrimPrefix(text, peerSessionPreamble))
return strings.HasPrefix(text, "<agent-message")
}
func startsHarness(text string) bool {
if strings.HasPrefix(text, "<task-notification>") {
return true
}
for _, prefix := range harnessPrefixes {
if strings.HasPrefix(text, prefix) {
return true
}
}
return false
}
// unwrapMidTurn returns the operator's text from the reminder Claude Code wraps
// around a message the operator sent while a turn was running.
func unwrapMidTurn(text string) (string, bool) {
index := strings.Index(text, midTurnWrapper)
if index < 0 || !strings.HasPrefix(text, "<system-reminder>") {
return "", false
}
body := text[index+len(midTurnWrapper):]
if tail := strings.Index(body, midTurnWrapperTail); tail >= 0 {
body = body[:tail]
} else {
body = strings.TrimSuffix(strings.TrimSpace(body), "</system-reminder>")
}
body = strings.TrimSpace(body)
return body, body != ""
}
// agentReport extracts the report an agent delivered. The CLI frames it as
// `<agent-message from="id">`, a hand-back preamble, then the report with every
// line indented; the origin's handbackReportText is the same report unframed.
func agentReport(text string, origin injectedOrigin) injected {
sender := origin.From
body := text
if match := agentMessageOpen.FindStringSubmatchIndex(text); match != nil {
if sender == "" && match[2] >= 0 {
sender = text[match[2]:match[3]]
}
body = text[match[1]:]
}
if end := strings.LastIndex(body, "</agent-message>"); end >= 0 {
body = body[:end]
}
framed := false
if marker := strings.Index(body, handbackMarker); marker >= 0 && strings.Contains(body[:marker], "[Subagent hand-back]") {
body = body[marker+len(handbackMarker):]
framed = true
}
body = strings.Trim(body, "\n")
if framed {
body = dedentReport(body)
}
body = strings.TrimSpace(body)
display := body
if report := strings.TrimSpace(origin.HandbackReportText); report != "" {
display = report
}
if display == "" {
return injected{class: classHidden}
}
label := strings.TrimSpace(origin.Name)
if label == "" {
label = sender
}
return injected{class: classAgentReport, id: "agent-report-" + contentKey(sender, body), text: display, sender: label}
}
// dedentReport removes the two-space indent the harness adds to every line of a
// handed-back report.
func dedentReport(body string) string {
lines := strings.Split(body, "\n")
for i, line := range lines {
lines[i] = strings.TrimPrefix(line, " ")
}
return strings.Join(lines, "\n")
}
// taskNotice turns a `<task-notification>` block into its one-line notice.
func taskNotice(text string) (injected, bool) {
match := taskNotificationPattern.FindStringSubmatch(text)
if match == nil {
return injected{}, false
}
block := match[1]
key := ""
if id := taskToolUsePattern.FindStringSubmatch(block); id != nil {
key = id[1]
} else if id := taskIDPattern.FindStringSubmatch(block); id != nil {
key = id[1]
}
status := ""
if found := taskStatusPattern.FindStringSubmatch(block); found != nil {
status = found[1]
}
summary := ""
if found := taskSummaryPattern.FindStringSubmatch(block); found != nil {
summary = strings.Join(strings.Fields(found[1]), " ")
}
return taskNoticeLine(key, status, summary), true
}
func taskNoticeLine(key, status, summary string) injected {
verb := "finished"
switch strings.ToLower(status) {
case "failed", "error":
verb = "failed"
case "killed", "stopped", "cancelled", "canceled":
verb = "stopped"
}
line := "Background task " + verb
if summary != "" {
line += ": " + summary
}
if key == "" {
key = contentKey(status, summary)
}
return injected{class: classNotice, id: "task-notice-" + key + "-" + strings.ToLower(status), text: line}
}
func contentKey(parts ...string) string {
sum := sha256.Sum256([]byte(strings.Join(parts, "\x00")))
return hex.EncodeToString(sum[:8])
}
// message is the transcript message an agent report or notice becomes. It has
// the assistant role so a client that ignores Kind still draws it on the agent's
// side.
func (item injected) message(sessionID string, created int64) protocol.ChatMessage {
kind := protocol.ChatMessageKindNotice
if item.class == classAgentReport {
kind = protocol.ChatMessageKindAgentReport
}
part := protocol.ChatPart{Type: protocol.ChatPartText, ID: protocol.ChatDeltaPartID(item.id, protocol.ChatPartText, 0), Text: item.text, Name: item.sender}
return protocol.ChatMessage{ID: item.id, SessionID: sessionID, Role: protocol.ChatRoleAssistant, Kind: kind, CreatedAt: created, Parts: []protocol.ChatPart{part}}
}
// emitInjected publishes a live agent report or notice once per identity. The
// same delivery can reach the stream twice (a task notification is both a
// system event and a user line), so later copies are dropped.
func (s *session) emitInjected(item injected) {
if item.id == "" || (item.class != classAgentReport && item.class != classNotice) {
return
}
s.mu.Lock()
if s.injectedSeen == nil {
s.injectedSeen = map[string]bool{}
}
if s.injectedSeen[item.id] {
s.mu.Unlock()
return
}
s.injectedSeen[item.id] = true
turn := s.turnID
s.mu.Unlock()
message := item.message(s.id, 0)
part := message.Parts[0]
s.emit(protocol.ChatEventFrame{
SessionID: s.id,
NativeTurnID: turn,
MessageID: message.ID,
MessageKind: message.Kind,
Kind: protocol.ChatEventText,
Delta: part.Text,
Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: part.ID, Name: part.Name},
})
}