package claude import ( "bufio" "encoding/json" "errors" "io" "os" "time" "git.a-wan.net/alan/pipelines/internal/protocol" ) func applyToolMetadata(shell *protocol.ChatShell, name string, input json.RawMessage, timestamp string) { if shell.StartedAt == 0 { if stamp, ok := transcriptTime(timestamp); ok && stamp > 0 { shell.StartedAt = stamp } } if shell.TaskType == "" { if name == "Bash" { shell.TaskType = "shell" } else { shell.TaskType = "agent" } } var fields struct { Description string `json:"description"` } if json.Unmarshal(input, &fields) == nil && fields.Description != "" && shell.Description == "" { shell.Description = boundedText(fields.Description, 2048) } } // SDK task events identify the initiating tool use, then task_id correlates // progress messages which omit tool_use_id. They do not all carry a timestamp. // Missing event times stay absent: replay wall time is not task creation time. func (s *session) handleTaskMetadata(raw []byte) { var event struct { TaskID string `json:"task_id"` ToolUseID string `json:"tool_use_id"` TaskType string `json:"task_type"` Description string `json:"description"` Summary string `json:"summary"` LastTool string `json:"last_tool_name"` Timestamp string `json:"timestamp"` Usage struct { DurationMS *int64 `json:"duration_ms"` Tools *int64 `json:"tool_uses"` Tokens *int64 `json:"total_tokens"` } `json:"usage"` } if json.Unmarshal(raw, &event) != nil { return } s.mu.Lock() snapshot := s.shells[event.ToolUseID] if snapshot == nil && event.TaskID != "" { for _, candidate := range s.shells { if candidate.taskID == event.TaskID { snapshot = candidate break } } } if snapshot == nil { s.mu.Unlock() return } if event.TaskID != "" { snapshot.taskID = event.TaskID } // Out-of-order readback/progress must not replace newer recorded progress. if event.Usage.DurationMS != nil && snapshot.shell.DurationMS != nil && *event.Usage.DurationMS < *snapshot.shell.DurationMS { s.mu.Unlock() return } shell := &snapshot.shell if event.TaskType != "" { shell.TaskType = boundedText(event.TaskType, 128) } if event.Description != "" { shell.Description = boundedText(event.Description, 2048) } if event.Summary != "" { shell.Progress = boundedText(event.Summary, 2048) } if event.LastTool != "" { shell.LastTool = boundedText(event.LastTool, 256) } if stamp, ok := transcriptTime(event.Timestamp); ok && stamp > shell.UpdatedAt { shell.UpdatedAt = stamp } keepCounter := func(target **int64, value *int64) { if value != nil && *value >= 0 && (*target == nil || *value >= **target) { copy := *value *target = © } } keepCounter(&shell.DurationMS, event.Usage.DurationMS) keepCounter(&shell.ToolCount, event.Usage.Tools) keepCounter(&shell.TokenCount, event.Usage.Tokens) copy := *shell s.mu.Unlock() s.emit(protocol.ChatEventFrame{SessionID: s.id, Kind: protocol.ChatEventShell, Shell: ©}) } // The durable transcript records the timestamp of each initiating tool call. // Enrich known tasks only; historical tool calls do not establish membership. // The size/mtime key avoids repeatedly scanning an unchanged transcript when // an older task has no recorded initiating message. Reads keep the existing // transcript byte/line limits and never fail the primary task-list request. func (s *session) enrichShellStarts() { // A separate lock serializes optional metadata IO without holding the chat // state lock. The clock below schedules retries only, never a task timestamp. s.shellMetadataMu.Lock() defer s.shellMetadataMu.Unlock() s.mu.Lock() wanted := map[string]bool{} for id, snapshot := range s.shells { if snapshot.shell.Status == protocol.ChatShellRunning && snapshot.shell.StartedAt == 0 { wanted[id] = true } } s.mu.Unlock() if len(wanted) == 0 { return } now := time.Now() if now.Before(s.shellScanAfter) { return } s.shellScanAfter = now.Add(5 * time.Second) path := s.shellTranscriptPath if path == "" { if now.Before(s.shellLookupAfter) { return } s.shellLookupAfter = now.Add(30 * time.Second) path = findTranscriptFile(s.id) if path == "" { return } s.shellTranscriptPath = path } info, err := os.Stat(path) if err != nil { if !now.Before(s.shellLookupAfter) { s.shellTranscriptPath = "" } return } covered := true for id := range wanted { if !s.shellTranscriptTargets[id] { covered = false break } } if covered && s.shellTranscriptSize == info.Size() && s.shellTranscriptMtime == info.ModTime().UnixNano() { return } // Cache failures too: an oversized/malformed unchanged file is not scanned // again on every list refresh. A changed file gets another bounded attempt. s.shellTranscriptSize, s.shellTranscriptMtime = info.Size(), info.ModTime().UnixNano() s.shellTranscriptTargets = wanted if info.Size() > maxTranscriptBytes { return } records, err := readShellStartRecords(path, wanted) if err != nil { return } s.mu.Lock() defer s.mu.Unlock() for id, record := range records { if snapshot := s.shells[id]; snapshot != nil { applyToolMetadata(&snapshot.shell, record.name, record.input, record.timestamp) } } } type shellStartRecord struct { name string input json.RawMessage timestamp string } // Retain only the targeted tool-call metadata, not an entire conversation. func readShellStartRecords(path string, wanted map[string]bool) (map[string]shellStartRecord, error) { file, err := os.Open(path) if err != nil { return nil, err } defer file.Close() bounded := &io.LimitedReader{R: file, N: maxTranscriptBytes + 1} scanner := bufio.NewScanner(bounded) scanner.Buffer(make([]byte, 0, 64<<10), maxLineBytes) records := map[string]shellStartRecord{} for scanner.Scan() { var entry transcriptEntry if json.Unmarshal(scanner.Bytes(), &entry) != nil || entry.Type != "assistant" || entry.IsSidechain { continue } for _, block := range decodeBlocks(entry.Message.Content) { if block.Type != "tool_use" || !wanted[block.ID] { continue } if _, seen := records[block.ID]; seen { continue } if stamp, ok := transcriptTime(entry.Timestamp); !ok || stamp <= 0 { continue } records[block.ID] = shellStartRecord{name: block.Name, input: truncateJSON(block.Input, 64<<10), timestamp: entry.Timestamp} } } if err := scanner.Err(); err != nil { return nil, err } if bounded.N <= 0 { return nil, errors.New("Claude task transcript exceeded read limit") } return records, nil }