Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

51.0 KB
Raw Blame
package repo

import (
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"

	"agentflow/internal/domain"
	"gorm.io/gorm"
)

type analyticsAccumulator struct {
	item          domain.AnalyticsBreakdown
	durations     []int64
	duration      int64
	execDurations []int64
	execDuration  int64

	inputTokens      int64
	outputTokens     int64
	cacheReadTokens  int64
	cacheWriteTokens int64
	toolCalls        int
	nodeRuns         int
	retriedNodes     int
	reworkNodes      int
	models           map[string]int
	nodeTypes        map[string]int
	nodeCount        int
	issueIDs         map[string]struct{}
}

type analyticsVersionAccumulator struct {
	item          domain.AnalyticsWorkflowVersion
	durations     []int64
	duration      int64
	execDurations []int64
	execDuration  int64
}

type analyticsUserAccumulator struct {
	item domain.AnalyticsUserUsage
}

type analyticsProjectAccumulator struct {
	item   domain.AnalyticsProjectUsage
	issues map[string]struct{}
}

type analyticsRunSignals struct {
	toolSucceeded int
	toolFailed    int
	interventions int
}

// Analytics returns a read-only, vendor-neutral operational view across runs.
func (r *AnalyticsRepo) Analytics(filter domain.AnalyticsFilter) domain.AnalyticsSnapshot {
	return r.analyticsWithRuns(filter, nil)
}

// analyticsWithRuns is Analytics with an optional pre-fetched run list. Prefetched
// runs must cover filter.ProjectIDs without a created_at window; the time window is
// still applied in Go by the same predicates, so every aggregate is identical to
// the self-fetching path. Nil keeps the original behavior.
func (r *AnalyticsRepo) analyticsWithRuns(filter domain.AnalyticsFilter, prefetched []domain.Run) (out domain.AnalyticsSnapshot) {
	overview := filter.Scope == "overview"
	now := time.Now().UTC()
	out = domain.AnalyticsSnapshot{
		Filter:   filter,
		Summary:  domain.AnalyticsSummary{GeneratedAt: now},
		Coverage: domain.AnalyticsCoverage{AdapterEvents: map[string]int{}, LogLevels: map[string]int{}},
	}
	defer applyAnalyticsCNY(&out)
	trends := map[string]*domain.AnalyticsTrendPoint{}
	trendIssues := map[string]map[string]struct{}{}
	weekHourZone := analyticsWeekHourLocation(filter.TimeZone)
	var weekHour [7][24]domain.AnalyticsWeekHourCell
	workflows, agents, executors, models, nodes, categories, sources := map[string]*analyticsAccumulator{}, map[string]*analyticsAccumulator{}, map[string]*analyticsAccumulator{}, map[string]*analyticsAccumulator{}, map[string]*analyticsAccumulator{}, map[string]*analyticsAccumulator{}, map[string]*analyticsAccumulator{}
	versions := map[string]*analyticsVersionAccumulator{}
	users := map[string]*analyticsUserAccumulator{}
	projects := map[string]*analyticsProjectAccumulator{}
	failures := map[string]*domain.AnalyticsFailure{}
	var terminalDurations, terminalExecDurations []int64
	var terminalDuration, terminalExecDuration, terminalWaitDuration int64
	terminal, firstPassSucceeded := 0, 0
	// 需求维度:每个需求的执行次数/失败次数/节点求和耗时。
	issueRuns, issueFailures, issueExec := map[string]int{}, map[string]int{}, map[string]int64{}
	// 成本识别与缓存命中率的累计基数。
	costKnownRuns, cacheReadTotal, cacheDenominator := 0, int64(0), int64(0)
	var includedRunIDs []string
	runTraceIndex := map[string]int{}
	var agentList []domain.AgentDefinition
	var executorList []domain.ExecutorDefinition
	var workflowList []domain.WorkflowDefinition
	var issueList []domain.Issue
	var runList []domain.Run
	if overview {
		// 概览用轻量需求列 + 当前 SOP 目录,避免拉全量 payload / 每条 Run 的冻结快照。
		_ = parallel(
			func() error { r, _ := r.runs.RunSummariesFor(filter, ""); runList = r; return nil },
			func() error { issueList = r.issues.IssueAnalyticsViews(); return nil },
			func() error { workflowList = r.catalog.Workflows(); return nil },
		)
	} else {
		_ = parallel(
			func() error { agentList = r.catalog.Agents(); return nil },
			func() error { executorList = r.catalog.Executors(); return nil },
			func() error { workflowList = r.catalog.Workflows(); return nil },
			func() error { issueList = r.issues.Issues(); return nil },
			func() error {
				if prefetched != nil {
					// Runs are priced and given snapshots in place below; copy so a
					// list shared across several reports is not modified.
					runList = append([]domain.Run(nil), prefetched...)
					return nil
				}
				r, _ := r.runs.RunSummariesFor(filter, "")
				runList = r
				return nil
			},
		)
	}

	agentDefs := map[string]domain.AgentDefinition{}
	for _, agent := range agentList {
		agentDefs[agent.ID] = agent
	}
	executorDefs := map[string]domain.ExecutorDefinition{}
	for _, executor := range executorList {
		executorDefs[executor.ID] = executor
	}
	workflowDefs := map[string]domain.WorkflowDefinition{}
	for _, workflow := range workflowList {
		workflowDefs[workflow.ID] = workflow
	}
	issuesByID := map[string]domain.Issue{}
	for _, issue := range issueList {
		issuesByID[issue.ID] = issue
	}
	// RunSummaries intentionally omits workflow snapshots on MySQL list paths.
	// Full scans need the frozen name/version/category/node bindings; overview
	// uses the live workflow catalog instead so the page does not hydrate every snapshot.
	if r.DB != nil && !overview {
		runIDs := make([]string, 0, len(runList))
		for _, run := range runList {
			if filter.WorkflowID != "" && run.WorkflowID != filter.WorkflowID {
				continue
			}
			if !analyticsRunInWindow(run, filter) || (filter.UserID != "" && !analyticsRunMatchesUser(run, filter.UserID, issuesByID[strings.TrimSpace(run.ExecutionContext.IssueID)])) {
				continue
			}
			issueID := strings.TrimSpace(run.ExecutionContext.IssueID)
			if filter.IssueSource != "" && !analyticsIssueMatchesSource(issuesByID[issueID], filter.IssueSource) {
				continue
			}
			if filter.RequirementsOnly && !analyticsIsRequirementIssue(issuesByID[issueID]) {
				continue
			}
			runIDs = append(runIDs, run.ID)
		}
		if snapshots, err := queryAnalyticsWorkflowSnapshots(r.DB, runIDs); err == nil {
			for i := range runList {
				if snapshot, ok := snapshots[runList[i].ID]; ok {
					runList[i].WorkflowSnapshot = snapshot
				}
			}
		}
	}

	for i := range runList {
		runList[i] = analyticsPricedRun(runList[i])
	}
	platformRuns := runList
	if err := r.analyticsActivity(filter, issueList, platformRuns, &out); err != nil {
		out.DataErrors = []string{"会话统计读取失败"}
		return out
	}
	if filter.Origin == "external" {
		runList = nil
		platformRuns = nil
		issueList = nil
	}
	externalRuns, externalMetadata, externalErr := r.analyticsInsightRuns(filter)
	if externalErr != nil {
		out.DataErrors = []string{"外部用量读取失败"}
		return out
	}
	runList = append(runList, externalRuns...)
	qualityTerminal, executionMeasured := 0, 0
	conversationIssues := map[string]struct{}{}
	conversationTrendIssues := map[string]map[string]struct{}{}

	for _, run := range runList {
		external, isExternal := externalMetadata[run.ID]
		if filter.WorkflowID != "" && run.WorkflowID != filter.WorkflowID {
			continue
		}
		if !isExternal && !analyticsRunInWindow(run, filter) {
			continue
		}
		issueID := strings.TrimSpace(run.ExecutionContext.IssueID)
		if filter.UserID != "" && !analyticsRunMatchesUser(run, filter.UserID, issuesByID[issueID]) {
			continue
		}
		if filter.IssueSource != "" && !analyticsIssueMatchesSource(issuesByID[issueID], filter.IssueSource) {
			continue
		}
		if filter.RequirementsOnly && !analyticsIsRequirementIssue(issuesByID[issueID]) {
			continue
		}
		if !isExternal && run.IsWorkspace() {
			accumulateConversationRun(&out.Summary, conversationIssues, trends, conversationTrendIssues, users, projects, sources, run, issuesByID[issueID], filter.Grain)
			continue
		}
		if !isExternal {
			includedRunIDs = append(includedRunIDs, run.ID)
			out.Summary.QualityRuns++
			out.Demo.CoveredRuns++
		} else {
			out.Summary.ExternalRuns++
		}

		out.Summary.TotalRuns++
		out.Summary.TotalTokens += run.Usage.TotalTokens
		out.Summary.TotalCostUSD += run.Usage.CostUSD
		out.Summary.InputTokens += run.Usage.InputTokens
		out.Summary.OutputTokens += run.Usage.OutputTokens
		out.Summary.CacheReadTokens += run.Usage.CacheReadTokens
		out.Summary.CacheWriteTokens += run.Usage.CacheWriteTokens
		out.Summary.ReasoningTokens += run.Usage.ReasoningTokens
		cacheReadTotal += run.Usage.CacheReadTokens
		cacheDenominator += run.Usage.InputTokens
		if !isExternal {
			cacheDenominator += run.Usage.CacheReadTokens
		}
		out.Summary.CostReportedUSD += run.Usage.CostUSD
		if usageCostKnown(run.Usage) {
			costKnownRuns++
		} else {
			out.Summary.CostUnknownRuns++
		}
		out.Summary.ToolCalls += run.ToolCalls
		out.Summary.Artifacts += runArtifactCount(run)
		out.Summary.TelemetryEvents += int(run.TelemetrySequence)
		if n := len(run.Telemetry); n > int(run.TelemetrySequence) {
			out.Summary.TelemetryEvents += n - int(run.TelemetrySequence)
		}
		out.Summary.LogRecords += int(run.LogSequence)
		if n := len(run.Logs); n > int(run.LogSequence) {
			out.Summary.LogRecords += n - int(run.LogSequence)
		}
		if run.TelemetrySequence > 0 || len(run.Telemetry) > 0 {
			out.Coverage.RunsWithTelemetry++
		}
		if run.LogSequence > 0 || len(run.Logs) > 0 {
			out.Coverage.RunsWithLogs++
		}

		reworks := runReworks(run)
		out.Summary.TotalReworks += reworks
		if reworks > 0 {
			out.Summary.ReworkedRuns++
		}
		duration, complete := analyticsRunDuration(run, now)
		// 执行耗时为 SOP 节点耗时之和,不含审批/排队/恢复等待。
		execDuration := runExecutionDuration(run)
		execKnown := !isExternal || external.execution.ExecutionDurationMs != nil
		if isExternal {
			duration = external.execution.FinishedAt.Sub(external.execution.StartedAt).Milliseconds()
			if execKnown {
				execDuration = *external.execution.ExecutionDurationMs
			}
		}
		if complete {
			terminal++
			terminalDuration += duration
			terminalDurations = append(terminalDurations, duration)
			if execKnown {
				executionMeasured++
				terminalExecDuration += execDuration
				terminalExecDurations = append(terminalExecDurations, execDuration)
			}
			if !isExternal {
				qualityTerminal++
				terminalWaitDuration += runWaitDuration(run, now)
			}
		}
		switch run.Status {
		case "running":
			out.Summary.ActiveRuns++
		case "waiting":
			out.Summary.WaitingRuns++
		case "succeeded":
			out.Summary.SucceededRuns++
			if !isExternal {
				out.Demo.CoveredSucceededRuns++
			}
			if !isExternal && reworks == 0 {
				firstPassSucceeded++
			}
		case "failed":
			out.Summary.FailedRuns++
			if issueID != "" {
				issueFailures[issueID]++
			}
		case "cancelled":
			out.Summary.CancelledRuns++
		}
		issue := issuesByID[issueID]
		traceID := strings.TrimSpace(run.ExecutionContext.TraceID)
		if traceID == "" {
			traceID = run.ID
		}
		projectID := domain.RunProjectID(run, issue.ProjectID)
		errorNodeID, errorMessage := analyticsRunError(run)
		trace := domain.AnalyticsRunTrace{
			ProjectID: projectID, IssueID: issueID, IssueSource: analyticsIssueSource(issue), WorkflowTaskID: run.ExecutionContext.TaskID,
			RunID: run.ID, TraceID: traceID, Status: run.Status, DurationMs: duration,
			Tokens: run.Usage.TotalTokens, CostUSD: run.Usage.CostUSD, CostKnown: usageCostKnown(run.Usage),
			ToolCalls: run.ToolCalls, ErrorNodeID: errorNodeID, ErrorMessage: errorMessage,
			CreatedAt: run.CreatedAt,
		}
		if tapdID := issue.RequirementTAPDID(); tapdID != "" {
			trace.ExternalID = tapdID
		}
		if issue.ExternalRef != nil {
			trace.ExternalURL = issue.ExternalRef.ExternalURL
		}
		if complete {
			trace.FinishedAt = runEndedAt(run, now)
		}
		if isExternal {
			trace.ExecutionDurationMs = external.execution.ExecutionDurationMs
			trace.Origin = "external"
			trace.SourceID = external.sourceID
			trace.WorkflowName = external.execution.Workflow.Name
			trace.ExternalID = external.execution.ExternalExecutionID
			trace.ExternalURL = external.execution.URL
			trace.IssueSource = ""
			trace.FinishedAt = external.execution.FinishedAt
		}
		runTraceIndex[run.ID] = len(out.RunTraces)
		out.RunTraces = append(out.RunTraces, trace)
		if issueID != "" {
			issueRuns[issueID]++
			issueExec[issueID] += execDuration
			accumulateIssueSource(sources, analyticsIssueSource(issuesByID[issueID]), run, execDuration)
		}

		workflow := run.WorkflowSnapshot
		if workflow.ID == "" {
			workflow = workflowDefs[run.WorkflowID]
		}
		workflowName := workflow.Name
		if workflowName == "" {
			workflowName = run.WorkflowID
		}
		category := analyticsWorkflowCategory(workflow, workflowDefs[run.WorkflowID])
		accumulateBreakdown(workflows, run.WorkflowID, workflowName, run, reworks, duration, complete, execDuration)
		if acc := workflows[run.WorkflowID]; acc != nil {
			acc.item.Category = category
			acc.nodeCount = len(workflow.Nodes)
			acc.nodeTypes = analyticsNodeTypes(workflow.Nodes)
		}
		if !isExternal {
			accumulateVersion(versions, run.WorkflowID, workflowName, workflow.Version, workflowDefs[run.WorkflowID].Version, run, duration, complete, execDuration)
			accumulateBreakdown(categories, category, "", run, reworks, duration, complete, execDuration)
			if acc := categories[category]; acc != nil && issueID != "" {
				if acc.issueIDs == nil {
					acc.issueIDs = map[string]struct{}{}
				}
				if run.Status == "succeeded" {
					acc.issueIDs[issueID] = struct{}{}
				}
			}
		} else {
			acc := workflows[run.WorkflowID]
			acc.item.QualityUnknownRuns++
			if !execKnown {
				acc.execDurations = acc.execDurations[:len(acc.execDurations)-1]
			}
		}
		// 趋势与每用户每日用量在概览态同样输出,节点级拆解仍只在完整扫描时计算。
		eventAt := run.CreatedAt
		if complete {
			eventAt = runEndedAt(run, now)
		}
		if isExternal {
			eventAt = external.execution.FinishedAt
		}
		eventAt = eventAt.UTC()
		day := eventAt.Format("2006-01-02")
		bucket := analyticsTrendBucket(eventAt, filter.Grain)
		point := analyticsTrendEntry(trends, bucket)
		point.Runs++
		if !usageCostKnown(run.Usage) {
			point.CostUnknownRuns++
		}
		point.Reworks += reworks
		point.Tokens += run.Usage.TotalTokens
		point.CostUSD += run.Usage.CostUSD
		point.InputTokens += run.Usage.InputTokens
		point.OutputTokens += run.Usage.OutputTokens
		point.CacheReadTokens += run.Usage.CacheReadTokens
		point.CacheWriteTokens += run.Usage.CacheWriteTokens
		point.ExecutionDurationMs += execDuration
		if complete {
			point.DurationMs += duration
		}
		if run.Status == "succeeded" {
			point.Succeeded++
		}
		if run.Status == "failed" {
			point.Failed++
		}
		local := eventAt.In(weekHourZone)
		cell := &weekHour[(int(local.Weekday())+6)%7][local.Hour()]
		cell.Runs++
		cell.Tokens += run.Usage.TotalTokens
		cell.CostUSD += run.Usage.CostUSD
		addAnalyticsTrendIssue(trendIssues, bucket, issueID)
		accumulateUserUsage(users, analyticsRunUserID(run, issuesByID[issueID]), day, run, duration, complete, execDuration)
		accumulateProjectUsage(projects, domain.RunProjectID(run, issuesByID[issueID].ProjectID), issueID, run)
		if isExternal {
			accumulateInsightModels(models, external.execution)
			continue
		}
		definition := map[string]domain.WorkflowNode{}
		for _, node := range workflow.Nodes {
			definition[node.ID] = node
		}
		for nodeID, nodeRun := range run.Nodes {
			if nodeRun == nil {
				continue
			}
			node := definition[nodeID]
			nodeDuration := int64(0)
			nodeComplete := !nodeRun.StartedAt.IsZero() && !nodeRun.FinishedAt.IsZero()
			if nodeComplete {
				nodeDuration = nodeRun.FinishedAt.Sub(nodeRun.StartedAt).Milliseconds()
			}
			key := run.WorkflowID + "/" + nodeID
			name := node.Name
			if name == "" {
				name = nodeID
			}
			accumulateNode(nodes, key, name, nodeRun, nodeDuration, nodeComplete)
			model := nodeRun.Model
			if model == "" && node.ExecutorID != "" {
				model = executorDefs[node.ExecutorID].Model
			}
			if model != "" {
				accumulateNode(models, model, model, nodeRun, nodeDuration, nodeComplete)
			}
			if nodeRun.Error != "" {
				code := normalizeFailure(nodeRun.Error)
				failureKey := nodeID + "\x00" + code
				if failures[failureKey] == nil {
					failures[failureKey] = &domain.AnalyticsFailure{Code: code, NodeID: nodeID}
				}
				failures[failureKey].Count++
			}
			if !overview {
				if node.AgentID != "" {
					accumulateNode(agents, node.AgentID, agentName(agentDefs, node.AgentID), nodeRun, nodeDuration, nodeComplete)
				}
				if node.ExecutorID != "" {
					accumulateNode(executors, node.ExecutorID, executorName(executorDefs, node.ExecutorID), nodeRun, nodeDuration, nodeComplete)
				}
			}
		}
	}
	// Tool outcome and human-decision facts live in append-only event tables,
	// not in Run summary columns. Load only matching tool-finish telemetry and
	// compact control events, then join them back to each auditable Run row.
	signals := r.analyticsRunSignals(includedRunIDs)
	for runID, signal := range signals {
		index, ok := runTraceIndex[runID]
		if !ok {
			continue
		}
		trace := &out.RunTraces[index]
		trace.ToolCallsSucceeded = signal.toolSucceeded
		trace.ToolCallsFailed = signal.toolFailed
		trace.HumanInterventions = signal.interventions
		out.Demo.ToolCallsSucceeded += signal.toolSucceeded
		out.Demo.ToolCallsFailed += signal.toolFailed
		out.Demo.HumanInterventions += signal.interventions
	}
	out.Demo.ToolCallsObserved = out.Demo.ToolCallsSucceeded + out.Demo.ToolCallsFailed
	if out.Demo.ToolCallsObserved > 0 {
		out.Demo.ToolSuccessRate = float64(out.Demo.ToolCallsSucceeded) * 100 / float64(out.Demo.ToolCallsObserved)
	}
	for _, trace := range out.RunTraces {
		if trace.Origin != "external" && trace.Status == "succeeded" && trace.HumanInterventions == 0 {
			out.Demo.AutomatedSucceededRuns++
		}
	}
	out.Summary.ConversationIssues = len(conversationIssues)
	for id := range conversationIssues {
		issue := issuesByID[id]
		if len(issue.DeliveryMRList()) > 0 {
			out.Summary.ConversationIssuesWithMR++
		}
		if issue.DeliveryState == "merged" {
			out.Summary.ConversationIssuesDelivered++
		}
	}
	if runs := out.Summary.TotalRuns; runs > 0 {
		out.Demo.AverageTokensPerRun = float64(out.Summary.TotalTokens-out.Summary.ConversationTokens) / float64(runs)
		if out.Demo.CoveredRuns > 0 {
			out.Demo.AverageHumanInterventions = float64(out.Demo.HumanInterventions) / float64(out.Demo.CoveredRuns)
		}
	}
	if out.Demo.CoveredSucceededRuns > 0 {
		out.Demo.AutomationRate = float64(out.Demo.AutomatedSucceededRuns) * 100 / float64(out.Demo.CoveredSucceededRuns)
	}
	sort.Slice(out.RunTraces, func(i, j int) bool {
		if out.RunTraces[i].CreatedAt.Equal(out.RunTraces[j].CreatedAt) {
			return out.RunTraces[i].RunID > out.RunTraces[j].RunID
		}
		return out.RunTraces[i].CreatedAt.After(out.RunTraces[j].CreatedAt)
	})
	// Coverage counts adapter/level distributions over the included runs. On
	// MySQL the generated columns make this an indexed GROUP BY; other
	// dialects (tests) compute the same numbers from the payloads.
	if !overview && len(includedRunIDs) > 0 {
		if r.isMySQL() {
			if adapters, levels, err := queryAnalyticsCoverage(r.DB, includedRunIDs); err == nil {
				out.Coverage.AdapterEvents = adapters
				out.Coverage.LogLevels = levels
			}
		} else {
			r.computeAnalyticsCoverage(includedRunIDs, &out.Coverage)
		}
	}

	if terminal > 0 {
		out.Summary.CompletionRate = float64(out.Summary.SucceededRuns) * 100 / float64(terminal)
		if qualityTerminal > 0 {
			out.Summary.FirstPassRate = float64(firstPassSucceeded) * 100 / float64(qualityTerminal)
		}
		out.Summary.AverageDurationMs = terminalDuration / int64(terminal)
		out.Summary.CancelRate = float64(out.Summary.CancelledRuns) * 100 / float64(terminal)
		if executionMeasured > 0 {
			out.Summary.ExecutionAverageDurationMs = terminalExecDuration / int64(executionMeasured)
		}
	}
	if attempts := out.Summary.SucceededRuns + out.Summary.FailedRuns; attempts > 0 {
		// 成功率排除取消的执行,取消率单独成列,避免"取消"污染成功率分母。
		out.Summary.SuccessRate = float64(out.Summary.SucceededRuns) * 100 / float64(attempts)
	}
	if cacheDenominator > 0 {
		out.Summary.CacheHitRate = float64(cacheReadTotal) * 100 / float64(cacheDenominator)
	}
	if out.Summary.TotalRuns > 0 {
		out.Summary.CostCoveragePct = float64(costKnownRuns) * 100 / float64(out.Summary.TotalRuns)
	}
	if qualityTerminal > 0 {
		out.Summary.WaitAverageDurationMs = terminalWaitDuration / int64(qualityTerminal)
	}
	if issues := len(issueRuns); issues > 0 {
		out.Summary.UniqueIssues = issues
		out.Summary.RunsPerIssue = float64(sumIssueCounts(issueRuns)) / float64(issues)
		out.Summary.FailuresPerIssue = float64(sumIssueCounts(issueFailures)) / float64(issues)
	}
	out.Summary.P50DurationMs = percentile(terminalDurations, 50)
	out.Summary.P95DurationMs = percentile(terminalDurations, 95)
	out.Summary.P99DurationMs = percentile(terminalDurations, 99)
	out.Summary.ExecutionP50DurationMs = percentile(terminalExecDurations, 50)
	out.Summary.ExecutionP95DurationMs = percentile(terminalExecDurations, 95)
	out.Summary.ExecutionP99DurationMs = percentile(terminalExecDurations, 99)
	if execValues := issueExecValues(issueExec); len(execValues) > 0 {
		out.Summary.IssueP50ExecutionDurationMs = percentile(execValues, 50)
		out.Summary.IssueP95ExecutionDurationMs = percentile(execValues, 95)
	}
	// 轻量维度(SOP、模型、失败原因、用户每日用量)在概览态同样输出,
	// Agent/CLI 与交付明细仍只在完整扫描时计算。
	out.Workflows = finalizeBreakdowns(workflows)
	out.Categories = finalizeBreakdowns(categories)
	out.WorkflowVersions = finalizeWorkflowVersions(versions)
	out.IssueSources = finalizeBreakdowns(sources)
	out.UserUsage = finalizeUserUsage(users)
	out.ProjectUsage = finalizeProjectUsage(projects)
	out.Models = finalizeBreakdowns(models)
	out.Nodes = finalizeBreakdowns(nodes)
	applyBreakdownShares(out.Workflows, out.Summary.TotalTokens, out.Summary.TotalCostUSD)
	applyBreakdownShares(out.Categories, out.Summary.TotalTokens, out.Summary.TotalCostUSD)
	applyBreakdownShares(out.IssueSources, out.Summary.TotalTokens, out.Summary.TotalCostUSD)
	applyBreakdownShares(out.Models, out.Summary.TotalTokens, out.Summary.TotalCostUSD)
	applyBreakdownShares(out.Nodes, out.Summary.TotalTokens, out.Summary.TotalCostUSD)
	for _, failure := range failures {
		out.Failures = append(out.Failures, *failure)
	}
	sort.Slice(out.Failures, func(i, j int) bool { return out.Failures[i].Count > out.Failures[j].Count })
	out.MRMerges, out.Summary.MergedMRsMissingTime = r.mrMergeAnalytics(filter, issuesByID)
	out.Summary.MergedMRs = len(out.MRMerges)
	for _, mr := range out.MRMerges {
		analyticsTrendEntry(trends, analyticsTrendBucket(mr.MergedAt, filter.Grain)).MergedMRs++
	}
	for _, point := range trends {
		if ids := trendIssues[point.Date]; ids != nil {
			point.Issues = len(ids)
		}
		point.ConversationIssues = len(conversationTrendIssues[point.Date])
		out.Trend = append(out.Trend, *point)
	}
	sort.Slice(out.Trend, func(i, j int) bool { return out.Trend[i].Date < out.Trend[j].Date })
	for weekday := range weekHour {
		for hour := range weekHour[weekday] {
			cell := weekHour[weekday][hour]
			if cell.Runs == 0 {
				continue
			}
			cell.Weekday, cell.Hour = weekday, hour
			out.WeekHour = append(out.WeekHour, cell)
		}
	}
	if overview {
		if filter.Origin != "external" {
			out.Delivery.Issues = countDeliveryGroups(filter, platformRuns, issuesByID)
		}
		out.Summary.InProgressIssues = countInProgressIssues(issueList, filter)
		return out
	}
	out.Agents = finalizeBreakdowns(agents)
	out.Executors = finalizeBreakdowns(executors)
	applyBreakdownShares(out.Agents, out.Summary.TotalTokens, out.Summary.TotalCostUSD)
	applyBreakdownShares(out.Executors, out.Summary.TotalTokens, out.Summary.TotalCostUSD)
	if filter.Origin != "external" {
		out.Deliveries = r.delivery.buildDeliveries(filter, now, platformRuns, workflowDefs, issuesByID)
	}
	out.Delivery = domain.SummarizeDeliveries(out.Deliveries)
	applyWeeklyThroughput(&out.Summary, out.Deliveries, now)
	out.Summary.InProgressIssues = countInProgressIssues(issueList, filter)
	return out
}

// analyticsHumanEventTypes are explicit human decisions. run.paused / run.resumed
// are excluded: they fire on user pause, but also on lease takeover and service
// recovery, and a single approval often emits pause+resume+gate together.
var analyticsHumanEventTypes = []string{
	"gate.approved",
	"node.passed",
	"gate.rejected",
	"node.retry_requested",
	"agent.turns.declined",
}

// analyticsRunSignals reads only the append-only facts needed by the Loop
// demo. It deliberately avoids hydrating logs, output, artifacts, and ordinary
// progress telemetry into the analytics request.
func (r *AnalyticsRepo) analyticsRunSignals(runIDs []string) map[string]analyticsRunSignals {
	out := map[string]analyticsRunSignals{}
	for start := 0; start < len(runIDs); start += 500 {
		batch := runIDs[start:min(start+500, len(runIDs))]
		r.accumulateToolSignals(out, batch)

		var eventRows []runEventRow
		if err := r.DB.Select("run_id", "type").Where("run_id IN ? AND type IN ?", batch, analyticsHumanEventTypes).Find(&eventRows).Error; err == nil {
			for _, row := range eventRows {
				signal := out[row.RunID]
				signal.interventions++
				out[row.RunID] = signal
			}
		}
	}
	return out
}

func (r *AnalyticsRepo) accumulateToolSignals(out map[string]analyticsRunSignals, batch []string) {
	if len(batch) == 0 || r.DB == nil {
		return
	}
	type toolRow struct {
		RunID     string `gorm:"column:run_id"`
		Succeeded int    `gorm:"column:succeeded"`
		Failed    int    `gorm:"column:failed"`
	}
	successExpr := "CASE WHEN json_extract(payload, '$.tool.success') IS NOT NULL THEN json_extract(payload, '$.tool.success') ELSE (CASE WHEN lower(coalesce(json_extract(payload, '$.level'), '')) = 'error' THEN 0 ELSE 1 END) END"
	filter := "json_extract(payload, '$.category') = ? AND json_extract(payload, '$.name') = ? AND json_extract(payload, '$.phase') = ?"
	if r.isMySQL() {
		successExpr = "CASE WHEN JSON_EXTRACT(payload, '$.tool.success') IS NOT NULL THEN JSON_EXTRACT(payload, '$.tool.success') ELSE (LOWER(COALESCE(JSON_UNQUOTE(JSON_EXTRACT(payload, '$.level')), '')) <> 'error') END"
		filter = "JSON_UNQUOTE(JSON_EXTRACT(payload, '$.category')) = ? AND JSON_UNQUOTE(JSON_EXTRACT(payload, '$.name')) = ? AND JSON_UNQUOTE(JSON_EXTRACT(payload, '$.phase')) = ?"
	}
	var rows []toolRow
	if err := r.DB.Table("run_telemetry").
		Select("run_id, SUM("+successExpr+") AS succeeded, SUM(1-("+successExpr+")) AS failed").
		Where("run_id IN ? AND "+filter, batch, "tool", "tool.call", "finish").
		Group("run_id").
		Scan(&rows).Error; err != nil {
		return
	}
	for _, row := range rows {
		signal := out[row.RunID]
		signal.toolSucceeded += row.Succeeded
		signal.toolFailed += row.Failed
		out[row.RunID] = signal
	}
}

func analyticsRunError(run domain.Run) (string, string) {
	ids := make([]string, 0, len(run.Nodes))
	for id, node := range run.Nodes {
		if node != nil && strings.TrimSpace(node.Error) != "" {
			ids = append(ids, id)
		}
	}
	if len(ids) == 0 {
		return "", ""
	}
	sort.Strings(ids)
	node := run.Nodes[ids[0]]
	return ids[0], normalizeFailure(node.Error)
}

// computeAnalyticsCoverage derives adapter/level coverage from raw payloads
// for dialects without the generated columns (test sqlite databases).
func (r *AnalyticsRepo) computeAnalyticsCoverage(runIDs []string, coverage *domain.AnalyticsCoverage) {
	for _, runID := range runIDs {
		telemetry, err := r.runs.loadRunTelemetryAll(runID)
		if err != nil {
			continue
		}
		for _, event := range telemetry {
			adapter := event.Source.Adapter
			if adapter == "" {
				adapter = "unknown"
			}
			coverage.AdapterEvents[adapter]++
		}
		logs, err := r.runs.loadRunLogsAll(runID)
		if err != nil {
			continue
		}
		for _, record := range logs {
			level := record.Level
			if level == "" {
				level = "info"
			}
			coverage.LogLevels[level]++
		}
	}
}

// queryAnalyticsCoverage groups telemetry adapters and log levels using the
// MySQL generated columns.
func queryAnalyticsCoverage(db *gorm.DB, runIDs []string) (map[string]int, map[string]int, error) {
	adapters := map[string]int{}
	levels := map[string]int{}
	placeholders := strings.TrimRight(strings.Repeat("?,", len(runIDs)), ",")
	args := make([]any, len(runIDs))
	for i, id := range runIDs {
		args[i] = id
	}
	coverageArgs := append(append(make([]any, 0, len(args)*2), args...), args...)
	type coverageRow struct {
		Kind  string `gorm:"column:kind"`
		Value string `gorm:"column:value"`
		Count int    `gorm:"column:count"`
	}
	var rows []coverageRow
	err := db.Raw(`
		SELECT 'adapter' AS kind, adapter AS value, COUNT(*) AS count
		FROM run_telemetry WHERE run_id IN (`+placeholders+`) GROUP BY value
		UNION ALL
		SELECT 'level' AS kind, level AS value, COUNT(*) AS count
		FROM run_logs WHERE run_id IN (`+placeholders+`) GROUP BY value`, coverageArgs...).Scan(&rows).Error
	if err != nil {
		return nil, nil, err
	}
	for _, row := range rows {
		if row.Kind == "adapter" {
			adapters[row.Value] = row.Count
		} else {
			levels[row.Value] = row.Count
		}
	}
	return adapters, levels, nil
}

func runReworks(run domain.Run) int {
	total := 0
	for _, node := range run.Nodes {
		total += node.ReworkCount
	}
	return total
}

func analyticsRunDuration(run domain.Run, now time.Time) (int64, bool) {
	complete := run.Status == "succeeded" || run.Status == "failed" || run.Status == "cancelled"
	return runDuration(run, now), complete
}

// analyticsWeekHourLocation resolves the heatmap zone; unknown or empty zones fall back to Asia/Shanghai.
func analyticsWeekHourLocation(name string) *time.Location {
	name = strings.TrimSpace(name)
	if name == "" || name == "Local" {
		name = "Asia/Shanghai"
	}
	if loc, err := time.LoadLocation(name); err == nil {
		return loc
	}
	if loc, err := time.LoadLocation("Asia/Shanghai"); err == nil {
		return loc
	}
	return time.FixedZone("Asia/Shanghai", 8*3600)
}

func analyticsTrendBucket(at time.Time, grain string) string {
	switch strings.ToLower(strings.TrimSpace(grain)) {
	case "week":
		year, week := at.ISOWeek()
		return fmt.Sprintf("%d-W%02d", year, week)
	case "month", "all":
		return at.Format("2006-01")
	default:
		return at.Format("2006-01-02")
	}
}

// analyticsTrendEntry 取用 bucket 对应的趋势点,缺失时新建并存回。
func analyticsTrendEntry(trends map[string]*domain.AnalyticsTrendPoint, bucket string) *domain.AnalyticsTrendPoint {
	point := trends[bucket]
	if point == nil {
		point = &domain.AnalyticsTrendPoint{Date: bucket}
		trends[bucket] = point
	}
	return point
}

// addAnalyticsTrendIssue 把需求 ID 记入 bucket 的需求集合;issueID 为空时不登记。
func addAnalyticsTrendIssue(trendIssues map[string]map[string]struct{}, bucket, issueID string) {
	if issueID == "" {
		return
	}
	if trendIssues[bucket] == nil {
		trendIssues[bucket] = map[string]struct{}{}
	}
	trendIssues[bucket][issueID] = struct{}{}
}

// analyticsRunInWindow 保持与既有行为一致:按 Run 创建时间过滤。
func analyticsRunInWindow(run domain.Run, filter domain.AnalyticsFilter) bool {
	if !filter.From.IsZero() && run.CreatedAt.Before(filter.From) {
		return false
	}
	if !filter.To.IsZero() && run.CreatedAt.After(filter.To) {
		return false
	}
	return true
}

func analyticsRunMatchesUser(run domain.Run, userID string, issue domain.Issue) bool {
	want := strings.TrimSpace(userID)
	if want == "" {
		return true
	}
	if strconv.FormatInt(run.ExecutionContext.ResponsibleUserID, 10) == want {
		return true
	}
	return issue.AssigneeUserID != 0 && strconv.FormatInt(issue.AssigneeUserID, 10) == want
}

// analyticsRunUserID 返回执行责任人;未写入时回退到需求责任人。
func analyticsRunUserID(run domain.Run, issue domain.Issue) string {
	if run.ExecutionContext.ResponsibleUserID != 0 {
		return strconv.FormatInt(run.ExecutionContext.ResponsibleUserID, 10)
	}
	if issue.AssigneeUserID != 0 {
		return strconv.FormatInt(issue.AssigneeUserID, 10)
	}
	return ""
}

func analyticsIssueMatchesSource(issue domain.Issue, source string) bool {
	want := strings.ToLower(strings.TrimSpace(source))
	if want == "" {
		return true
	}
	got := strings.ToLower(strings.TrimSpace(issue.Source))
	if got == "" {
		got = "local"
	}
	return got == want
}

func analyticsIsRequirementIssue(issue domain.Issue) bool {
	return issue.ID != "" && domain.IsRequirementWorkItem(issue)
}

// usageCostKnown 区分"成本为 0"与"成本未识别":显式上报/估算视为已识别,
// 旧数据(无 costStatus)按是否有成本金额判定。
func usageCostKnown(usage domain.TokenUsage) bool {
	switch strings.ToLower(strings.TrimSpace(usage.CostStatus)) {
	case "reported", "estimated":
		return true
	case "unknown":
		return false
	}
	return usage.CostUSD > 0
}

// analyticsWorkflowCategory 取 SOP 的受控统计标签,优先使用 Run 冻结的快照。
func analyticsWorkflowCategory(snapshot domain.WorkflowDefinition, fallback domain.WorkflowDefinition) string {
	if category := strings.TrimSpace(snapshot.MetricCategory); category != "" {
		return category
	}
	return strings.TrimSpace(fallback.MetricCategory)
}

func analyticsNodeTypes(nodes []domain.WorkflowNode) map[string]int {
	out := map[string]int{}
	for _, node := range nodes {
		kind := strings.TrimSpace(node.Type)
		if kind == "" {
			kind = "unknown"
		}
		out[kind]++
	}
	return out
}

func sumIssueCounts(values map[string]int) int {
	total := 0
	for _, count := range values {
		total += count
	}
	return total
}

func issueExecValues(values map[string]int64) []int64 {
	out := make([]int64, 0, len(values))
	for _, value := range values {
		out = append(out, value)
	}
	return out
}

// countInProgressIssues 统计仍未闭环的需求数(WIP 快照)。
func countInProgressIssues(issues []domain.Issue, filter domain.AnalyticsFilter) int {
	total := 0
	for _, issue := range issues {
		if !filter.MatchesProject(issue.ProjectID) {
			continue
		}
		if filter.WorkflowID != "" && issue.WorkflowID != filter.WorkflowID {
			continue
		}
		if filter.IssueSource != "" && !analyticsIssueMatchesSource(issue, filter.IssueSource) {
			continue
		}
		if filter.RequirementsOnly && !analyticsIsRequirementIssue(issue) {
			continue
		}
		if filter.UserID != "" && strconv.FormatInt(issue.AssigneeUserID, 10) != filter.UserID {
			continue
		}
		if !issueInProgress(issue) {
			continue
		}
		total++
	}
	return total
}

func issueInProgress(issue domain.Issue) bool {
	if strings.EqualFold(strings.TrimSpace(issue.DeliveryState), "merged") {
		return false
	}
	switch strings.ToLower(strings.TrimSpace(issue.Status)) {
	case "done", "closed", "cancelled", "canceled":
		return false
	}
	return true
}

// applyWeeklyThroughput 计算近 7 天的人均吞吐:唯一交付需求数 ÷ 有交付的成员数。
func applyWeeklyThroughput(summary *domain.AnalyticsSummary, deliveries []domain.AnalyticsDelivery, now time.Time) {
	since := now.AddDate(0, 0, -7)
	issues := map[string]struct{}{}
	contributors := map[string]struct{}{}
	for _, item := range deliveries {
		if !item.Delivered || item.LastRunAt.IsZero() {
			continue
		}
		if item.LastRunAt.Before(since) || item.LastRunAt.After(now.Add(time.Minute)) {
			continue
		}
		issues[item.IssueID] = struct{}{}
		if item.UserID != "" {
			contributors[item.UserID] = struct{}{}
		}
	}
	summary.WeeklyDeliveredIssues = len(issues)
	summary.WeeklyActiveContributors = len(contributors)
	if len(contributors) > 0 {
		summary.WeeklyThroughputPerUser = float64(len(issues)) / float64(len(contributors))
	}
}

func accumulateBreakdown(values map[string]*analyticsAccumulator, key, name string, run domain.Run, reworks int, duration int64, complete bool, execDuration int64) {
	value := values[key]
	if value == nil {
		value = &analyticsAccumulator{item: domain.AnalyticsBreakdown{Key: key, Name: name}}
		values[key] = value
	}
	if name != "" {
		value.item.Name = name
	}
	value.item.Runs++
	value.item.Reworks += reworks
	value.item.ToolCalls += run.ToolCalls
	accumulateBreakdownUsage(value, run.Usage)
	countBreakdownStatus(&value.item, run.Status, run.Status == "running" || run.Status == "waiting")
	if complete {
		accumulateBreakdownDuration(value, duration, execDuration)
	}
}

// accumulateBreakdownUsage 把单次执行的用量累加到维度累加器:Token/成本总量、
// 成本未识别计数与 Token 四分项。dimension 维度(SOP、节点、模型等)共用。
func accumulateBreakdownUsage(value *analyticsAccumulator, usage domain.TokenUsage) {
	if !usageCostKnown(usage) {
		value.item.CostUnknownRuns++
	}
	value.item.Tokens += usage.TotalTokens
	value.item.CostUSD += usage.CostUSD
	value.inputTokens += usage.InputTokens
	value.outputTokens += usage.OutputTokens
	value.cacheReadTokens += usage.CacheReadTokens
	value.cacheWriteTokens += usage.CacheWriteTokens
}

// countBreakdownStatus 按执行状态累加维度终态计数,active 由调用方按各自的状态词表判定。
func countBreakdownStatus(item *domain.AnalyticsBreakdown, status string, active bool) {
	switch status {
	case "succeeded":
		item.Succeeded++
	case "failed":
		item.Failed++
	case "cancelled":
		item.Cancelled++
	}
	if active {
		item.Active++
	}
}

// accumulateBreakdownDuration 记录一次有效耗时样本,供均值与 P95 使用。
func accumulateBreakdownDuration(value *analyticsAccumulator, duration, execDuration int64) {
	value.duration += duration
	value.durations = append(value.durations, duration)
	value.execDuration += execDuration
	value.execDurations = append(value.execDurations, execDuration)
}

func accumulateNode(values map[string]*analyticsAccumulator, key, name string, node *domain.NodeRun, duration int64, complete bool) {
	value := values[key]
	if value == nil {
		value = &analyticsAccumulator{item: domain.AnalyticsBreakdown{Key: key, Name: name}}
		values[key] = value
	}
	if name != "" {
		value.item.Name = name
	}
	value.item.Runs++
	value.item.Reworks += node.ReworkCount
	value.item.ToolCalls += node.ToolCalls
	accumulateBreakdownUsage(value, node.Usage)
	value.nodeRuns++
	if node.Attempt > 1 {
		value.retriedNodes++
	}
	if node.ReworkCount > 0 {
		value.reworkNodes++
	}
	if node.Model != "" {
		if value.models == nil {
			value.models = map[string]int{}
		}
		value.models[node.Model]++
	}
	countBreakdownStatus(&value.item, node.Status, node.Status == "running" || node.Status == "waiting_approval")
	if node.Status == "failed" {
		value.item.FailedNodes++
	}
	if complete {
		// 节点耗时本身就是"执行耗时",与双口径中的执行耗时同源。
		accumulateBreakdownDuration(value, duration, duration)
	}
}

// accumulateVersion 按 SOP 版本聚合,用于版本对比(样本不足时前端标注)。
func accumulateVersion(values map[string]*analyticsVersionAccumulator, workflowID, workflowName string, snapshotVersion int, fallbackVersion int, run domain.Run, duration int64, complete bool, execDuration int64) {
	version := snapshotVersion
	if version <= 0 {
		version = fallbackVersion
	}
	key := workflowID + "#" + strconv.Itoa(version)
	value := values[key]
	if value == nil {
		value = &analyticsVersionAccumulator{item: domain.AnalyticsWorkflowVersion{
			WorkflowID:         workflowID,
			Name:               workflowName,
			Version:            version,
			InsufficientSample: true,
		}}
		values[key] = value
	}
	if workflowName != "" {
		value.item.Name = workflowName
	}
	value.item.Runs++
	if !usageCostKnown(run.Usage) {
		value.item.CostUnknownRuns++
	}
	value.item.Tokens += run.Usage.TotalTokens
	value.item.CostUSD += run.Usage.CostUSD
	if run.Status == "succeeded" {
		value.item.Succeeded++
	}
	if run.Status == "failed" {
		value.item.Failed++
	}
	if complete {
		value.duration += duration
		value.durations = append(value.durations, duration)
		value.execDuration += execDuration
		value.execDurations = append(value.execDurations, execDuration)
	}
}

// analyticsUserEntry 返回"责任人 × 自然日"的累加器,不存在时新建;空责任人归为 unassigned。
func analyticsUserEntry(values map[string]*analyticsUserAccumulator, userID, day string) *analyticsUserAccumulator {
	if userID == "" {
		userID = "unassigned"
	}
	key := userID + "\x00" + day
	value := values[key]
	if value == nil {
		value = &analyticsUserAccumulator{item: domain.AnalyticsUserUsage{UserID: userID, Date: day, CostKnown: true}}
		values[key] = value
	}
	return value
}

// accumulateUserUsage 按"责任人 × 自然日"聚合用量。
func accumulateUserUsage(values map[string]*analyticsUserAccumulator, userID, day string, run domain.Run, duration int64, complete bool, execDuration int64) {
	value := analyticsUserEntry(values, userID, day)
	value.item.Runs++
	value.item.Tokens += run.Usage.TotalTokens
	value.item.InputTokens += run.Usage.InputTokens
	value.item.OutputTokens += run.Usage.OutputTokens
	value.item.CacheReadTokens += run.Usage.CacheReadTokens
	value.item.CacheWriteTokens += run.Usage.CacheWriteTokens
	value.item.CostUSD += run.Usage.CostUSD
	value.item.ExecutionDurationMs += execDuration
	if !usageCostKnown(run.Usage) {
		value.item.CostKnown = false
	}
	if run.Status == "succeeded" {
		value.item.Success++
	}
	if run.Status == "failed" {
		value.item.Failed++
	}
	if complete {
		value.item.DurationMs += duration
	}
}

func finalizeBreakdowns(values map[string]*analyticsAccumulator) []domain.AnalyticsBreakdown {
	out := make([]domain.AnalyticsBreakdown, 0, len(values))
	for _, value := range values {
		terminal := value.item.Succeeded + value.item.Failed
		if terminal > 0 {
			value.item.SuccessRate = float64(value.item.Succeeded) * 100 / float64(terminal)
		}
		if all := terminal + value.item.Cancelled; all > 0 {
			value.item.CancelRate = float64(value.item.Cancelled) * 100 / float64(all)
			value.item.ReworkRate = float64(value.item.Reworks) * 100 / float64(value.item.Runs)
		}
		if len(value.durations) > 0 {
			value.item.AverageDurationMs = value.duration / int64(len(value.durations))
			value.item.P95DurationMs = percentile(value.durations, 95)
		}
		if len(value.execDurations) > 0 {
			value.item.AverageExecutionDurationMs = value.execDuration / int64(len(value.execDurations))
			value.item.P95ExecutionDurationMs = percentile(value.execDurations, 95)
		}
		value.item.InputTokens = value.inputTokens
		value.item.OutputTokens = value.outputTokens
		value.item.CacheReadTokens = value.cacheReadTokens
		value.item.CacheWriteTokens = value.cacheWriteTokens
		value.item.ToolCalls = value.toolCalls
		value.item.NodeRuns = value.nodeRuns
		value.item.RetriedNodes = value.retriedNodes
		value.item.ReworkNodes = value.reworkNodes
		if value.nodeRuns > 0 {
			value.item.RetryRate = float64(value.retriedNodes) * 100 / float64(value.nodeRuns)
		}
		if len(value.models) > 0 {
			value.item.ModelMix = value.models
		}
		if len(value.nodeTypes) > 0 {
			value.item.NodeTypes = value.nodeTypes
			value.item.NodeCount = value.nodeCount
		}
		if len(value.issueIDs) > 0 {
			value.item.CompletedIssues = len(value.issueIDs)
		}
		out = append(out, value.item)
	}
	sort.Slice(out, func(i, j int) bool {
		if out[i].Runs == out[j].Runs {
			return out[i].Name < out[j].Name
		}
		return out[i].Runs > out[j].Runs
	})
	return out
}

func finalizeWorkflowVersions(values map[string]*analyticsVersionAccumulator) []domain.AnalyticsWorkflowVersion {
	out := make([]domain.AnalyticsWorkflowVersion, 0, len(values))
	for _, value := range values {
		terminal := value.item.Succeeded + value.item.Failed
		if terminal > 0 {
			value.item.SuccessRate = float64(value.item.Succeeded) * 100 / float64(terminal)
		}
		if len(value.durations) > 0 {
			value.item.AverageDurationMs = value.duration / int64(len(value.durations))
		}
		if len(value.execDurations) > 0 {
			value.item.AverageExecutionDurationMs = value.execDuration / int64(len(value.execDurations))
		}
		// 样本量不足时标注,避免版本对比被单次执行误导。
		value.item.InsufficientSample = value.item.Runs < 5
		out = append(out, value.item)
	}
	sort.Slice(out, func(i, j int) bool {
		if out[i].WorkflowID == out[j].WorkflowID {
			return out[i].Version > out[j].Version
		}
		return out[i].WorkflowID < out[j].WorkflowID
	})
	return out
}

func finalizeUserUsage(values map[string]*analyticsUserAccumulator) []domain.AnalyticsUserUsage {
	out := make([]domain.AnalyticsUserUsage, 0, len(values))
	for _, value := range values {
		out = append(out, value.item)
	}
	sort.Slice(out, func(i, j int) bool {
		if out[i].Date == out[j].Date {
			return out[i].Tokens > out[j].Tokens
		}
		return out[i].Date > out[j].Date
	})
	return out
}

// analyticsProjectEntry 返回项目的累加器,不存在时新建;空项目归为 unassigned。
func analyticsProjectEntry(values map[string]*analyticsProjectAccumulator, projectID string) *analyticsProjectAccumulator {
	if projectID == "" {
		projectID = "unassigned"
	}
	value := values[projectID]
	if value == nil {
		value = &analyticsProjectAccumulator{item: domain.AnalyticsProjectUsage{ProjectID: projectID, CostKnown: true}, issues: map[string]struct{}{}}
		values[projectID] = value
	}
	return value
}

func accumulateProjectUsage(values map[string]*analyticsProjectAccumulator, projectID, issueID string, run domain.Run) {
	value := analyticsProjectEntry(values, projectID)
	value.item.Runs++
	value.item.Tokens += run.Usage.TotalTokens
	value.item.CostUSD += run.Usage.CostUSD
	if !usageCostKnown(run.Usage) {
		value.item.CostKnown = false
	}
	if run.Status == "succeeded" {
		value.item.Success++
	}
	if run.Status == "failed" {
		value.item.Failed++
	}
	if issueID != "" {
		value.issues[issueID] = struct{}{}
	}
}

func finalizeProjectUsage(values map[string]*analyticsProjectAccumulator) []domain.AnalyticsProjectUsage {
	out := make([]domain.AnalyticsProjectUsage, 0, len(values))
	for _, value := range values {
		value.item.UniqueIssues = len(value.issues)
		out = append(out, value.item)
	}
	sort.Slice(out, func(i, j int) bool {
		if out[i].Tokens == out[j].Tokens {
			return out[i].Runs > out[j].Runs
		}
		return out[i].Tokens > out[j].Tokens
	})
	return out
}

// applyBreakdownShares 回填各维度占全局 Token/成本的比例,用于占比结构展示。
func applyBreakdownShares(list []domain.AnalyticsBreakdown, totalTokens int64, totalCostUSD float64) {
	for i := range list {
		if totalTokens > 0 {
			list[i].TokenSharePct = float64(list[i].Tokens) * 100 / float64(totalTokens)
		}
		if totalCostUSD > 0 {
			list[i].CostSharePct = list[i].CostUSD * 100 / totalCostUSD
		}
	}
}

// analyticsIssueSource 归一需求来源,未标注的本地需求归为 local。
func analyticsIssueSource(issue domain.Issue) string {
	source := strings.ToLower(strings.TrimSpace(issue.Source))
	if source == "" {
		return "local"
	}
	return source
}

// analyticsSourceEntry 返回需求来源的累加器,不存在时新建;空来源归为 local。
func analyticsSourceEntry(values map[string]*analyticsAccumulator, source string) *analyticsAccumulator {
	if source == "" {
		source = "local"
	}
	value := values[source]
	if value == nil {
		value = &analyticsAccumulator{item: domain.AnalyticsBreakdown{Key: source, Name: source}}
		values[source] = value
	}
	return value
}

// accumulateIssueSource 按需求来源聚合执行量、Token、成本与执行耗时。
func accumulateIssueSource(values map[string]*analyticsAccumulator, source string, run domain.Run, execDuration int64) {
	value := analyticsSourceEntry(values, source)
	value.item.Runs++
	value.item.Tokens += run.Usage.TotalTokens
	value.item.CostUSD += run.Usage.CostUSD
	value.inputTokens += run.Usage.InputTokens
	value.outputTokens += run.Usage.OutputTokens
	value.cacheReadTokens += run.Usage.CacheReadTokens
	value.cacheWriteTokens += run.Usage.CacheWriteTokens
	value.item.ToolCalls += run.ToolCalls
	if run.Status == "succeeded" {
		value.item.Succeeded++
		if value.issueIDs == nil {
			value.issueIDs = map[string]struct{}{}
		}
		value.issueIDs[strings.TrimSpace(run.ExecutionContext.IssueID)] = struct{}{}
	}
	if run.Status == "failed" {
		value.item.Failed++
	}
	if run.Status == "cancelled" {
		value.item.Cancelled++
	}
	if execDuration > 0 {
		value.execDuration += execDuration
		value.execDurations = append(value.execDurations, execDuration)
	}
}

func percentile(values []int64, pct int) int64 {
	if len(values) == 0 {
		return 0
	}
	copyValues := append([]int64(nil), values...)
	sort.Slice(copyValues, func(i, j int) bool { return copyValues[i] < copyValues[j] })
	index := (len(copyValues)*pct+99)/100 - 1
	if index < 0 {
		index = 0
	}
	if index >= len(copyValues) {
		index = len(copyValues) - 1
	}
	return copyValues[index]
}

func normalizeFailure(message string) string {
	message = strings.TrimSpace(strings.Split(message, "\n")[0])
	if len(message) > 160 {
		message = message[:160]
	}
	if message == "" {
		return "unknown failure"
	}
	return message
}

func agentName(values map[string]domain.AgentDefinition, id string) string {
	if value, ok := values[id]; ok && value.Name != "" {
		return value.Name
	}
	return id
}
func executorName(values map[string]domain.ExecutorDefinition, id string) string {
	if value, ok := values[id]; ok && value.Name != "" {
		return value.Name
	}
	return id
}

// accumulateConversationRun counts a conversation workspace: its model usage
// joins the token and cost totals, trend, user, project and requirement-source
// breakdowns, while run counts, statuses, durations and the SOP requirement
// counts stay SOP-only. Its requirements are counted apart, per trend bucket in
// trendIssues.
func accumulateConversationRun(summary *domain.AnalyticsSummary, issues map[string]struct{}, trends map[string]*domain.AnalyticsTrendPoint, trendIssues map[string]map[string]struct{}, users map[string]*analyticsUserAccumulator, projects map[string]*analyticsProjectAccumulator, sources map[string]*analyticsAccumulator, run domain.Run, issue domain.Issue, grain string) {
	usage := run.Usage
	issueID := strings.TrimSpace(run.ExecutionContext.IssueID)
	summary.ConversationWorkspaces++
	summary.ConversationTokens += usage.TotalTokens
	summary.ConversationCostUSD += usage.CostUSD
	summary.TotalTokens += usage.TotalTokens
	summary.TotalCostUSD += usage.CostUSD
	summary.CostReportedUSD += usage.CostUSD
	summary.InputTokens += usage.InputTokens
	summary.OutputTokens += usage.OutputTokens
	summary.CacheReadTokens += usage.CacheReadTokens
	summary.CacheWriteTokens += usage.CacheWriteTokens
	summary.ReasoningTokens += usage.ReasoningTokens
	if issueID != "" {
		issues[issueID] = struct{}{}
		summary.ConversationLinkedWorkspaces++
	}
	// Same timestamp the analytics window filters on.
	at := run.CreatedAt.UTC()
	bucket := analyticsTrendBucket(at, grain)
	point := analyticsTrendEntry(trends, bucket)
	point.Tokens += usage.TotalTokens
	point.CostUSD += usage.CostUSD
	point.ConversationWorkspaces++
	point.ConversationTokens += usage.TotalTokens
	point.ConversationCostUSD += usage.CostUSD
	point.InputTokens += usage.InputTokens
	point.OutputTokens += usage.OutputTokens
	point.CacheReadTokens += usage.CacheReadTokens
	point.CacheWriteTokens += usage.CacheWriteTokens
	addAnalyticsTrendIssue(trendIssues, bucket, issueID)
	if usage.TotalTokens == 0 && usage.CostUSD == 0 && issueID == "" {
		return
	}
	user := analyticsUserEntry(users, analyticsRunUserID(run, issue), at.Format("2006-01-02"))
	user.item.Tokens += usage.TotalTokens
	user.item.InputTokens += usage.InputTokens
	user.item.OutputTokens += usage.OutputTokens
	user.item.CacheReadTokens += usage.CacheReadTokens
	user.item.CacheWriteTokens += usage.CacheWriteTokens
	user.item.CostUSD += usage.CostUSD
	project := analyticsProjectEntry(projects, domain.RunProjectID(run, issue.ProjectID))
	project.item.Tokens += usage.TotalTokens
	project.item.CostUSD += usage.CostUSD
	if issueID == "" {
		return
	}
	project.issues[issueID] = struct{}{}
	value := analyticsSourceEntry(sources, analyticsIssueSource(issue))
	value.item.Tokens += usage.TotalTokens
	value.item.CostUSD += usage.CostUSD
	value.inputTokens += usage.InputTokens
	value.outputTokens += usage.OutputTokens
	value.cacheReadTokens += usage.CacheReadTokens
	value.cacheWriteTokens += usage.CacheWriteTokens
}