Implemented an --llm-concurrency flag in the Go application that enforces a global LLM concurrency cap

internal/framework/runner/runner_test.go

@@ -6,7 +6,10 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"testing"
+	"time"
 
 	"gitea.maximumdirect.net/eric/audita/internal/core/config"
 	"gitea.maximumdirect.net/eric/audita/internal/core/schema"
@@ -112,15 +115,20 @@ func TestRunnerProposalsExecutePerChunkSection(t *testing.T) {
 		{ID: 3, Text: "five six"},
 	}}
 
-	seenSections := make([]contracts.SectionMetadata, 0)
-	seenSegmentCounts := make([]int, 0)
+	var (
+		mu                sync.Mutex
+		seenBySection     = make(map[int]contracts.SectionMetadata)
+		segmentCountBySec = make(map[int]int)
+	)
 	r := New(fakeFactory{modules: map[string]contracts.TranscriptModule{
 		"m": fakeModule{key: "m", policy: proposals.ReplacementPolicyRequireUnique, proposeF: func(req contracts.ProposalRequest) ([]proposals.CorrectionProposal, error) {
 			if req.Section == nil {
 				t.Fatalf("expected section metadata on proposal request")
 			}
-			seenSections = append(seenSections, *req.Section)
-			seenSegmentCounts = append(seenSegmentCounts, len(req.WorkingTranscript.Segments))
+			mu.Lock()
+			seenBySection[req.Section.Index] = *req.Section
+			segmentCountBySec[req.Section.Index] = len(req.WorkingTranscript.Segments)
+			mu.Unlock()
 			return nil, nil
 		}},
 	}})
@@ -138,15 +146,117 @@ func TestRunnerProposalsExecutePerChunkSection(t *testing.T) {
 	if len(out.ModuleResults) != 1 {
 		t.Fatalf("expected one module result, got %+v", out.ModuleResults)
 	}
-	if len(seenSections) != 3 {
-		t.Fatalf("expected 3 chunked proposal calls, got %d", len(seenSections))
+	if len(seenBySection) != 3 {
+		t.Fatalf("expected 3 chunked proposal calls, got %d", len(seenBySection))
 	}
-	for i, section := range seenSections {
+	for i := 0; i < 3; i++ {
+		section, ok := seenBySection[i]
+		if !ok {
+			t.Fatalf("expected section %d to be observed", i)
+		}
 		if section.Index != i {
 			t.Fatalf("expected section index %d, got %+v", i, section)
 		}
-		if seenSegmentCounts[i] != 1 {
-			t.Fatalf("expected one segment per section call, got %d at index %d", seenSegmentCounts[i], i)
+		if segmentCountBySec[i] != 1 {
+			t.Fatalf("expected one segment per section call, got %d at index %d", segmentCountBySec[i], i)
+		}
+	}
+}
+
+func TestRunnerProposalSectionConcurrencyBoundedByPrimaryLLMConcurrency(t *testing.T) {
+	cfg := config.Default()
+	cfg.MaxSectionTokens = 3
+	cfg.MinSectionTokens = 0
+	cfg.PrimaryLLM.Concurrency = 2
+
+	transcript := &schema.Transcript{Segments: []schema.Segment{
+		{ID: 1, Text: "one two"},
+		{ID: 2, Text: "three four"},
+		{ID: 3, Text: "five six"},
+		{ID: 4, Text: "seven eight"},
+	}}
+
+	var inFlight int32
+	var maxInFlight int32
+	r := New(fakeFactory{modules: map[string]contracts.TranscriptModule{
+		"m": fakeModule{key: "m", policy: proposals.ReplacementPolicyRequireUnique, proposeF: func(req contracts.ProposalRequest) ([]proposals.CorrectionProposal, error) {
+			current := atomic.AddInt32(&inFlight, 1)
+			for {
+				prior := atomic.LoadInt32(&maxInFlight)
+				if current <= prior || atomic.CompareAndSwapInt32(&maxInFlight, prior, current) {
+					break
+				}
+			}
+			time.Sleep(25 * time.Millisecond)
+			atomic.AddInt32(&inFlight, -1)
+			return nil, nil
+		}},
+	}})
+
+	_, err := r.Run(context.Background(), RunInput{
+		Config:     &cfg,
+		Transcript: transcript,
+		ModuleSpecs: []contracts.ModuleRunSpec{
+			{ModuleKey: "m", InstanceName: "m"},
+		},
+	})
+	if err != nil {
+		t.Fatalf("Run error: %v", err)
+	}
+	if maxInFlight < 2 {
+		t.Fatalf("expected proposal execution to run concurrently, got max in-flight %d", maxInFlight)
+	}
+	if maxInFlight > 2 {
+		t.Fatalf("expected proposal concurrency <= 2, got %d", maxInFlight)
+	}
+}
+
+func TestRunnerProposalIndexOrderingIsDeterministicAcrossParallelSections(t *testing.T) {
+	cfg := config.Default()
+	cfg.MaxSectionTokens = 3
+	cfg.MinSectionTokens = 0
+	cfg.PrimaryLLM.Concurrency = 3
+
+	transcript := &schema.Transcript{Segments: []schema.Segment{
+		{ID: 1, Text: "alpha one"},
+		{ID: 2, Text: "bravo two"},
+		{ID: 3, Text: "charlie three"},
+	}}
+
+	r := New(fakeFactory{modules: map[string]contracts.TranscriptModule{
+		"m": fakeModule{key: "m", policy: proposals.ReplacementPolicyRequireUnique, proposeF: func(req contracts.ProposalRequest) ([]proposals.CorrectionProposal, error) {
+			if len(req.WorkingTranscript.Segments) != 1 {
+				t.Fatalf("expected one segment per section, got %d", len(req.WorkingTranscript.Segments))
+			}
+			seg := req.WorkingTranscript.Segments[0]
+			// Sleep inversely by ID to force completion order to differ from section order.
+			time.Sleep(time.Duration(4-seg.ID) * 10 * time.Millisecond)
+			return []proposals.CorrectionProposal{
+				{TargetSegmentID: seg.ID, OriginalText: seg.Text, CorrectedText: strings.ToUpper(seg.Text), Confidence: 1},
+			}, nil
+		}},
+	}})
+
+	out, err := r.Run(context.Background(), RunInput{
+		Config:     &cfg,
+		Transcript: transcript,
+		ModuleSpecs: []contracts.ModuleRunSpec{
+			{ModuleKey: "m", InstanceName: "m"},
+		},
+	})
+	if err != nil {
+		t.Fatalf("Run error: %v", err)
+	}
+	if len(out.ModuleResults) != 1 {
+		t.Fatalf("expected one module result, got %+v", out.ModuleResults)
+	}
+	if got := len(out.ModuleResults[0].AppliedChanges); got != 3 {
+		t.Fatalf("expected three applied changes, got %d", got)
+	}
+	for i, change := range out.ModuleResults[0].AppliedChanges {
+		wantID := i + 1
+		if change.TargetSegmentID != wantID {
+			t.Fatalf("expected deterministic applied-change order by section/segment, got %+v", out.ModuleResults[0].AppliedChanges)
 		}
 	}
 }