fix: eliminate 3 race conditions in parallel task execution

Race 1 — learnings.jsonl cherry-pick conflict:
  Add .gitattributes with merge=union for memory/*.jsonl so git
  automatically resolves concurrent appends without conflicts.

Race 2 — auditLog concurrent writes:
  Add auditMu sync.Mutex to Engine; lock around file open+write
  so parallel goroutines never interleave audit log entries.

Race 3 — same-file cherry-pick conflicts:
  Parse 'Files:' line from SESSION_PLAN.md tasks into planTask.Files.
  Group tasks into waves using groupTasksByFileOverlap — tasks sharing
  a file go into separate waves that run sequentially. Tasks with
  non-overlapping files stay in the same wave and run in parallel.

Author: Patel230

.gitattributes

@@ -0,0 +1,4 @@
+# Append-only JSONL files: use union merge so concurrent cherry-picks
+# never conflict — git keeps all lines from both sides.
+memory/learnings.jsonl  merge=union
+memory/failures.jsonl   merge=union

internal/evolution/engine.go

@@ -10,6 +10,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 
 	iteragent "github.com/GrayCodeAI/iteragent"
@@ -73,6 +74,7 @@ type Engine struct {
 	toolMap       map[string]iteragent.Tool // cached at construction — avoids re-init per call
 	tools         []iteragent.Tool          // cached tool slice for agent construction
 	skills        *iteragent.SkillSet       // cached skills — loaded once per engine
+	auditMu       sync.Mutex               // guards concurrent writes to audit.jsonl
 }
 
 // generateTraceID creates a random hex trace ID for request correlation.
@@ -390,6 +392,7 @@ func (e *Engine) handlePRReviewAndMerge(ctx context.Context, p iteragent.Provide
 }
 
 // auditLog appends a tool call or error to .iterate/audit.jsonl for debugging.
+// The mutex makes it safe to call concurrently from parallel task goroutines.
 func (e *Engine) auditLog(eventType, tool, detail string) {
 	auditPath := filepath.Join(e.repoPath, ".iterate", "audit.jsonl")
 	_ = os.MkdirAll(filepath.Dir(auditPath), 0o755)
@@ -400,14 +403,16 @@ func (e *Engine) auditLog(eventType, tool, detail string) {
 		"tool": tool,
 	}
 	if detail != "" {
-		// Truncate long details
 		if len(detail) > 200 {
 			detail = detail[:200] + "..."
 		}
 		entry["detail"] = detail
 	}
 
 	data, _ := json.Marshal(entry)
+
+	e.auditMu.Lock()
+	defer e.auditMu.Unlock()
 	f, err := os.OpenFile(auditPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
 	if err != nil {
 		return

internal/evolution/engine_extended_test.go

@@ -142,14 +142,14 @@ func TestWithTimeout_CreatesContext(t *testing.T) {
 	if !ok {
 		t.Error("expected deadline to be set")
 	}
-	if time.Until(deadline) > defaultPhaseTimeout {
-		t.Error("deadline should be within default timeout")
+	if time.Until(deadline) > timeoutImplement {
+		t.Error("deadline should be within implement timeout")
 	}
 }
 
 func TestWithTimeout_DefaultTimeout(t *testing.T) {
-	if defaultPhaseTimeout != 30*time.Minute {
-		t.Errorf("expected 30 minutes, got %s", defaultPhaseTimeout)
+	if timeoutImplement != 40*time.Minute {
+		t.Errorf("expected 40 minutes, got %s", timeoutImplement)
 	}
 }
 

internal/evolution/git_test.go

@@ -469,8 +469,8 @@ func TestWithTimeout_Deadline(t *testing.T) {
 	if !ok {
 		t.Fatal("expected deadline")
 	}
-	if time.Until(deadline) > defaultPhaseTimeout {
-		t.Error("deadline should be within default timeout")
+	if time.Until(deadline) > timeoutImplement {
+		t.Error("deadline should be within implement timeout")
 	}
 }
 

internal/evolution/parsing.go

@@ -10,6 +10,7 @@ type planTask struct {
 	Number      int
 	Title       string
 	Description string
+	Files       []string // parsed from "Files: ..." line — used for parallel conflict detection
 }
 
 func parseSessionPlanTasks(plan string) []planTask {
@@ -53,6 +54,15 @@ func parseSessionPlanTasks(plan string) []planTask {
 
 		if current != nil {
 			descLines = append(descLines, line)
+			// Parse "Files: a, b, c" line to populate task.Files.
+			if strings.HasPrefix(strings.TrimSpace(line), "Files:") {
+				raw := strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(line), "Files:"))
+				for _, f := range strings.Split(raw, ",") {
+					if f := strings.TrimSpace(f); f != "" {
+						current.Files = append(current.Files, f)
+					}
+				}
+			}
 		}
 	}
 
@@ -64,6 +74,60 @@ func parseSessionPlanTasks(plan string) []planTask {
 	return tasks
 }
 
+// groupTasksByFileOverlap splits tasks into sequential waves.
+// Tasks within a wave have no overlapping declared files and can run in parallel.
+// Tasks that share a file with any task already in the current wave start a new wave.
+func groupTasksByFileOverlap(tasks []planTask) [][]planTask {
+	var waves [][]planTask
+	var currentWave []planTask
+	waveFiles := map[string]bool{}
+
+	for _, task := range tasks {
+		// If task declares no files, always start a new wave (safe default).
+		if len(task.Files) == 0 {
+			if len(currentWave) > 0 {
+				waves = append(waves, currentWave)
+			}
+			waves = append(waves, []planTask{task})
+			currentWave = nil
+			waveFiles = map[string]bool{}
+			continue
+		}
+
+		// Check if any of this task's files are already claimed in the current wave.
+		conflict := false
+		for _, f := range task.Files {
+			if waveFiles[f] {
+				conflict = true
+				break
+			}
+		}
+
+		if conflict {
+			// Start a new wave.
+			if len(currentWave) > 0 {
+				waves = append(waves, currentWave)
+			}
+			currentWave = []planTask{task}
+			waveFiles = map[string]bool{}
+			for _, f := range task.Files {
+				waveFiles[f] = true
+			}
+		} else {
+			// Add to current wave.
+			currentWave = append(currentWave, task)
+			for _, f := range task.Files {
+				waveFiles[f] = true
+			}
+		}
+	}
+
+	if len(currentWave) > 0 {
+		waves = append(waves, currentWave)
+	}
+	return waves
+}
+
 type issueResponse struct {
 	IssueNum int
 	Status   string

internal/evolution/phases.go

@@ -186,13 +186,25 @@ func (e *Engine) RunImplementPhase(ctx context.Context, p iteragent.Provider) er
 	return nil
 }
 
-// runTasksParallel runs all tasks concurrently (up to maxParallelTasks at once).
-// Each task runs in an isolated git worktree; successful commits are
-// cherry-picked back to the current branch in task order.
+// runTasksParallel groups tasks by file overlap into waves, then runs each wave
+// in parallel (up to maxParallelTasks concurrent). Tasks sharing declared files
+// are placed in separate waves and run sequentially to prevent cherry-pick conflicts.
 func (e *Engine) runTasksParallel(ctx context.Context, p iteragent.Provider, tasks []planTask, systemPrompt string, skills *iteragent.SkillSet, protectedWarning string) {
+	waves := groupTasksByFileOverlap(tasks)
+	e.logger.Info("task waves planned", "waves", len(waves), "tasks", len(tasks))
+
+	for waveIdx, wave := range waves {
+		e.logger.Info("running wave", "wave", waveIdx+1, "tasks", len(wave))
+		e.runWave(ctx, p, wave, systemPrompt, skills, protectedWarning)
+	}
+}
+
+// runWave runs all tasks in a single wave concurrently then cherry-picks their commits.
+// Tasks in a wave are guaranteed to have non-overlapping declared files.
+func (e *Engine) runWave(ctx context.Context, p iteragent.Provider, tasks []planTask, systemPrompt string, skills *iteragent.SkillSet, protectedWarning string) {
 	type taskResult struct {
 		task    planTask
-		commits []string // new commit hashes from worktree, in order
+		commits []string
 		success bool
 	}