Fix the five library adoption review findings

internal/framework/processreport/llm.go

@@ -29,86 +29,74 @@ func BuildUtilization(output *runner.RunOutput, backends map[string]config.Backe
 		return result
 	}
 	result.RunWallTimeMS = output.RunWallTimeMS
-	for id, backend := range backends {
-		group := llm.ObservationSnapshot{}
-		for _, call := range output.Observations.Calls {
-			if call.Prompt.BackendID == id {
-				group.Calls = append(group.Calls, call)
-				addModuleCall(&result, call)
+	groups := make(map[string]*llm.ObservationSnapshot, len(backends))
+	callBackends := make(map[uint64]string, len(output.Observations.Calls))
+	moduleIndices := make(map[string]int)
+	moduleIndex := func(key, instance string) int {
+		if i, ok := moduleIndices[instance]; ok {
+			return i
+		}
+		i := len(result.Modules)
+		moduleIndices[instance] = i
+		result.Modules = append(result.Modules, reporting.ModuleUtilization{ModuleKey: key, ModuleInstance: instance})
+		return i
+	}
+	// Seed configured order, including modules that made no LLM calls.
+	for _, module := range output.ModuleResults {
+		i := moduleIndex(module.ModuleKey, module.ModuleInstance)
+		result.Modules[i].ModuleWallTimeMS = module.CompletedAt.Sub(module.StartedAt).Milliseconds()
+	}
+	for _, call := range output.Observations.Calls {
+		id := call.Prompt.BackendID
+		if groups[id] == nil {
+			groups[id] = &llm.ObservationSnapshot{}
+		}
+		groups[id].Calls = append(groups[id].Calls, call)
+		callBackends[call.CallID] = id
+		if call.Context.ModuleInstance != "" {
+			i := moduleIndex(call.Context.ModuleKey, call.Context.ModuleInstance)
+			switch call.Context.Role {
+			case "proposal":
+				result.Modules[i].ProposalLLMCalls++
+			case "validation":
+				result.Modules[i].ValidationLLMCalls++
 			}
 		}
+	}
+	for _, event := range output.Observations.Events {
+		if id, ok := callBackends[event.CallID]; ok {
+			groups[id].Events = append(groups[id].Events, event)
+		}
+	}
+	for id, backend := range backends {
+		group := groups[id]
+		if group == nil {
+			group = &llm.ObservationSnapshot{}
+		}
 		var wait, generation, retry, wall time.Duration
 		for _, call := range group.Calls {
 			wall += call.WallDuration
 		}
-		for _, event := range output.Observations.Events {
-			if hasCall(group.Calls, event.CallID) {
-				group.Events = append(group.Events, event)
-				if event.Kind == string(pk.ExecutionFinished) {
-					wait += event.CapacityWait
-					generation += event.GenerationDuration
-					retry += event.RetryDelay
-				}
+		for _, event := range group.Events {
+			if event.Kind == string(pk.ExecutionFinished) {
+				wait += event.CapacityWait
+				generation += event.GenerationDuration
+				retry += event.RetryDelay
 			}
 		}
 		result.Backends[id] = reporting.BackendUtilization{
 			Concurrency: backend.Concurrency, QueueCapacity: backend.QueueCapacity,
-			LLMSummary:     mapLLMSummary(llm.Summarize(group)),
+			LLMSummary:     mapLLMSummary(llm.Summarize(*group)),
 			CapacityWaitMS: wait.Milliseconds(), GenerationMS: generation.Milliseconds(),
 			RetryDelayMS: retry.Milliseconds(), LogicalWallMS: wall.Milliseconds(),
 		}
 	}
-	for _, module := range output.ModuleResults {
-		found := false
-		for i := range result.Modules {
-			if result.Modules[i].ModuleInstance == module.ModuleInstance {
-				result.Modules[i].ModuleWallTimeMS = module.CompletedAt.Sub(module.StartedAt).Milliseconds()
-				found = true
-				break
-			}
-		}
-		if !found {
-			result.Modules = append(result.Modules, reporting.ModuleUtilization{ModuleKey: module.ModuleKey, ModuleInstance: module.ModuleInstance, ModuleWallTimeMS: module.CompletedAt.Sub(module.StartedAt).Milliseconds()})
-		}
-	}
 	for _, timing := range output.ValidatorTimings {
 		result.Validators = append(result.Validators, reporting.ValidatorUtilization{ModuleKey: timing.ModuleKey, ModuleInstance: timing.ModuleInstance, ValidatorKey: timing.ValidatorName, LLMBacked: timing.LLMBacked, Calls: timing.Calls, ElapsedMS: timing.ElapsedMS})
 	}
 	return result
 }
 
-func hasCall(calls []llm.LogicalCall, id uint64) bool {
-	for _, call := range calls {
-		if call.CallID == id {
-			return true
-		}
-	}
-	return false
-}
-
-func addModuleCall(result *reporting.UtilizationDiagnostics, call llm.LogicalCall) {
-	if call.Context.ModuleInstance == "" {
-		return
-	}
-	for i := range result.Modules {
-		if result.Modules[i].ModuleInstance == call.Context.ModuleInstance {
-			if call.Context.Role == "proposal" {
-				result.Modules[i].ProposalLLMCalls++
-			} else if call.Context.Role == "validation" {
-				result.Modules[i].ValidationLLMCalls++
-			}
-			return
-		}
-	}
-	module := reporting.ModuleUtilization{ModuleKey: call.Context.ModuleKey, ModuleInstance: call.Context.ModuleInstance}
-	if call.Context.Role == "proposal" {
-		module.ProposalLLMCalls++
-	} else if call.Context.Role == "validation" {
-		module.ValidationLLMCalls++
-	}
-	result.Modules = append(result.Modules, module)
-}
-
 type executionCall struct {
 	CallID    uint64                             `json:"call_id"`
 	Context   structuredoutput.DiagnosticContext `json:"context"`
@@ -150,13 +138,12 @@ type executionEvent struct {
 func BuildLLMExecution(snapshot llm.ObservationSnapshot) any {
 	calls := make([]executionCall, 0, len(snapshot.Calls))
 	events := make([]executionEvent, 0, len(snapshot.Events))
+	eventsByCall := make(map[uint64][]llm.ExecutionObservation, len(snapshot.Calls))
+	for _, event := range snapshot.Events {
+		eventsByCall[event.CallID] = append(eventsByCall[event.CallID], event)
+	}
 	for _, call := range snapshot.Calls {
-		group := llm.ObservationSnapshot{Calls: []llm.LogicalCall{call}}
-		for _, event := range snapshot.Events {
-			if event.CallID == call.CallID {
-				group.Events = append(group.Events, event)
-			}
-		}
+		group := llm.ObservationSnapshot{Calls: []llm.LogicalCall{call}, Events: eventsByCall[call.CallID]}
 		var finished *time.Time
 		if !call.Finished.IsZero() {
 			value := call.Finished