fix(llmloop): scope async memory compression to each RunPerFile conversation

The Runner is shared by all concurrent per-file review goroutines, but it
held a single compressionMu/pendingJob slot for async memory compression.
With concurrency > 1 that shared slot caused four defects (#384):

1. Cross-file apply: tryApplyPendingCompression had no owner check, so
   file B could splice file A's rebuilt history into its own messages.
2. Cross-file cancel/replace: the warning-threshold paths canceled
   whichever file's job happened to be pending, surfacing spurious
   "context canceled" errors at the gateway; triggerAsyncCompression
   overwrote the slot unconditionally, wasting the superseded request.
3. Same-call start-then-cancel: the soft-threshold trigger fired before
   the new messages were appended, so an append that crossed the warning
   threshold canceled the job started microseconds earlier.
4. The pendingJob == nil fast-path read in addNextMessage was unlocked.

Fix: move the bookkeeping into a compressionState owned by each
RunPerFile call and thread it through trigger/apply/cancel. The
nil-pending gate is now an atomic check-and-set inside
triggerAsyncCompression under st.mu, and the async trigger moved to the
end of addNextMessage, gated on the post-append count sitting strictly
between the soft and warning thresholds. RunPerFile defers a cancel so
no job outlives its conversation. Aggregate token counters and warnings
stay Runner-level.

Intentional behavior deltas, all strictly safer: the async snapshot now
includes the just-appended round; an in-flight job is canceled when
RunPerFile returns instead of running up to 5 minutes orphaned; no async
job starts when the call is about to return false.

Verified: new regression tests (cross-file isolation via a channel-gated
fake client, owner-only summary apply with post-snapshot suffix
preserved, no start-then-cancel in one update, 4 concurrent RunPerFile
calls under -race); all existing compression tests updated to the
per-conversation API; full suite green with -race; coverage 81.1%.
E2E: 2-file concurrent review against a local OpenAI-compatible stub
with compression exercised — zero "context canceled", both files done.

Fixes #384

Author: chethanuk

internal/llmloop/compression.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"strings"
+	"sync"
 	"sync/atomic"
 	"time"
 
@@ -41,6 +42,16 @@ type compressionJob struct {
 	snapshotLen int // message count when the snapshot was taken
 }
 
+// compressionState is the async-compression bookkeeping for a single
+// conversation (one RunPerFile call). The Runner is shared by concurrent
+// per-file goroutines, so this state must not live on the Runner: a shared
+// slot lets one file apply, cancel, or replace another file's compression
+// job (#384).
+type compressionState struct {
+	mu         sync.Mutex
+	pendingJob *compressionJob
+}
+
 // CountMessagesTokens returns the rough token count of msgs by summing the
 // per-message text token count. Exported because both review and scan top
 // layers may want it for pre-flight checks.
@@ -252,31 +263,36 @@ func (r *Runner) runCompression(ctx context.Context, msgs []llm.Message, filePat
 	return rebuilt, nil
 }
 
-// triggerAsyncCompression kicks off a background compression job.
-func (r *Runner) triggerAsyncCompression(ctx context.Context, messages []llm.Message, filePath string) {
+// triggerAsyncCompression kicks off a background compression job for the
+// conversation owning st. A no-op when a job is already pending — the
+// check-and-set happens under st.mu so concurrent callers cannot replace
+// (and thereby leak) an in-flight job.
+func (r *Runner) triggerAsyncCompression(ctx context.Context, st *compressionState, messages []llm.Message, filePath string) {
+	st.mu.Lock()
+	if st.pendingJob != nil {
+		st.mu.Unlock()
+		return
+	}
 	msgSnapshot := copyMessages(messages)
-
 	asyncCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Minute)
-
 	job := &compressionJob{done: make(chan struct{}), cancel: cancel, snapshotLen: len(messages)}
-	r.compressionMu.Lock()
-	r.pendingJob = job
-	r.compressionMu.Unlock()
+	st.pendingJob = job
+	st.mu.Unlock()
 
 	go func() {
 		defer cancel()
 		rebuilt, err := r.runCompression(asyncCtx, msgSnapshot, filePath)
 
-		r.compressionMu.Lock()
-		defer r.compressionMu.Unlock()
+		st.mu.Lock()
+		defer st.mu.Unlock()
 
-		if r.pendingJob != job {
+		if st.pendingJob != job {
 			return // cancelled or superseded
 		}
 		if err != nil {
 			// Compression failed — abandon the job rather than applying a
 			// truncated/unmodified snapshot over live messages.
-			r.pendingJob = nil
+			st.pendingJob = nil
 			close(job.done)
 			return
 		}
@@ -288,10 +304,10 @@ func (r *Runner) triggerAsyncCompression(ctx context.Context, messages []llm.Mes
 // tryApplyPendingCompression checks whether a background compression has
 // completed and swaps the rebuilt messages into place. Returns true if
 // applied.
-func (r *Runner) tryApplyPendingCompression(messages *[]llm.Message) bool {
-	r.compressionMu.Lock()
-	job := r.pendingJob
-	r.compressionMu.Unlock()
+func (r *Runner) tryApplyPendingCompression(st *compressionState, messages *[]llm.Message) bool {
+	st.mu.Lock()
+	job := st.pendingJob
+	st.mu.Unlock()
 
 	if job == nil {
 		return false
@@ -300,8 +316,8 @@ func (r *Runner) tryApplyPendingCompression(messages *[]llm.Message) bool {
 	select {
 	case <-job.done:
 		applied := false
-		r.compressionMu.Lock()
-		if r.pendingJob == job && job.rebuilt != nil {
+		st.mu.Lock()
+		if st.pendingJob == job && job.rebuilt != nil {
 			rebuilt := job.rebuilt
 			// Preserve any messages appended after the snapshot was taken —
 			// the background job only compressed messages[:snapshotLen].
@@ -311,23 +327,24 @@ func (r *Runner) tryApplyPendingCompression(messages *[]llm.Message) bool {
 			*messages = rebuilt
 			applied = true
 		}
-		if r.pendingJob == job {
-			r.pendingJob = nil
+		if st.pendingJob == job {
+			st.pendingJob = nil
 		}
-		r.compressionMu.Unlock()
+		st.mu.Unlock()
 		return applied
 	default:
 		return false
 	}
 }
 
-// cancelPendingCompression aborts any in-flight background compression.
-func (r *Runner) cancelPendingCompression() {
-	r.compressionMu.Lock()
-	defer r.compressionMu.Unlock()
+// cancelPendingCompression aborts the conversation's in-flight background
+// compression, if any.
+func (r *Runner) cancelPendingCompression(st *compressionState) {
+	st.mu.Lock()
+	defer st.mu.Unlock()
 
-	if r.pendingJob != nil {
-		r.pendingJob.cancel()
-		r.pendingJob = nil
+	if st.pendingJob != nil {
+		st.pendingJob.cancel()
+		st.pendingJob = nil
 	}
 }

internal/llmloop/loop.go

@@ -39,8 +39,9 @@ type Deps struct {
 }
 
 // Runner is a per-session (across files) executor of the LLM tool-use
-// loop. Token counters, warnings, and the optional background compression
-// job are aggregated across every RunPerFile call.
+// loop. Token counters and warnings are aggregated across every RunPerFile
+// call; background memory compression is scoped to each RunPerFile
+// conversation (see compressionState).
 type Runner struct {
 	deps                  Deps
 	totalInputTokens      int64 // atomically updated
@@ -51,8 +52,6 @@ type Runner struct {
 	warnings              []AgentWarning
 	toolCallsMu           sync.Mutex
 	toolCalls             map[string]int64
-	compressionMu         sync.Mutex
-	pendingJob            *compressionJob
 }
 
 // NewRunner returns a Runner bound to the given dependencies.
@@ -153,6 +152,11 @@ func (r *Runner) RunPerFile(ctx context.Context, messages []llm.Message, newPath
 	consecutiveEmptyRounds := 0
 	sessionID := uuid.NewString()
 
+	// Async compression is owned by this conversation alone; the deferred
+	// cancel aborts any job still in flight when the conversation ends.
+	st := &compressionState{}
+	defer r.cancelPendingCompression(st)
+
 	for toolReqCount > 0 {
 		select {
 		case <-ctx.Done():
@@ -250,7 +254,7 @@ func (r *Runner) RunPerFile(ctx context.Context, messages []llm.Message, newPath
 			consecutiveEmptyRounds = 0
 		}
 
-		succeed := r.addNextMessage(ctx, content, calls, results, &messages, newPath)
+		succeed := r.addNextMessage(ctx, content, calls, results, &messages, newPath, st)
 		if !succeed {
 			fmt.Fprintf(stdout.Writer(), "[ocr] Context compression exceeded threshold for %s, stopping.\n", newPath)
 			break
@@ -430,23 +434,18 @@ func (r *Runner) executeToolCall(ctx context.Context, newPath string, call llm.T
 // warning (80%) MaxTokens thresholds. Returns false when even after
 // synchronous compression the conversation is still over the warning
 // threshold — caller should stop the loop in that case.
-func (r *Runner) addNextMessage(ctx context.Context, assistantContent string, toolCalls []llm.ToolCall, results []tool.ToolCallResult, messages *[]llm.Message, filePath string) bool {
+func (r *Runner) addNextMessage(ctx context.Context, assistantContent string, toolCalls []llm.ToolCall, results []tool.ToolCallResult, messages *[]llm.Message, filePath string, st *compressionState) bool {
 	maxAllowed := r.deps.Template.MaxTokens
 	softLimit := int(float64(maxAllowed) * tokenSoftThreshold)
 	warnLimit := int(float64(maxAllowed) * tokenWarningThreshold)
 
-	r.tryApplyPendingCompression(messages)
-
-	tokenCount := CountMessagesTokens(*messages)
+	r.tryApplyPendingCompression(st, messages)
 
-	if tokenCount > warnLimit {
-		r.cancelPendingCompression()
+	// A conversation can already be over the warning threshold before this
+	// round's messages are appended (e.g. an oversized initial prompt).
+	if CountMessagesTokens(*messages) > warnLimit {
+		r.cancelPendingCompression(st)
 		*messages, _ = r.runCompression(ctx, *messages, filePath)
-		tokenCount = CountMessagesTokens(*messages)
-	}
-
-	if tokenCount > softLimit && r.pendingJob == nil {
-		r.triggerAsyncCompression(ctx, *messages, filePath)
 	}
 
 	if len(toolCalls) > 0 {
@@ -461,11 +460,19 @@ func (r *Runner) addNextMessage(ctx context.Context, assistantContent string, to
 
 	finalCount := CountMessagesTokens(*messages)
 	if finalCount > warnLimit {
-		r.cancelPendingCompression()
+		r.cancelPendingCompression(st)
 		*messages, _ = r.runCompression(ctx, *messages, filePath)
+		finalCount = CountMessagesTokens(*messages)
+	}
+
+	// Trigger async compression only after all appends for this update, so
+	// a job is never started and then immediately cancelled by the same
+	// call (#384), and never started when we are about to return false.
+	if finalCount > softLimit && finalCount < warnLimit {
+		r.triggerAsyncCompression(ctx, st, *messages, filePath)
 	}
 
-	return CountMessagesTokens(*messages) < warnLimit
+	return finalCount < warnLimit
 }
 
 // lookupTool returns the provider for a given tool from the registry, or