feat: add bd resolve-conflicts command for JSONL merge conflicts (bd-7e7ddffa.1)

Implements a new command to resolve git merge conflict markers in JSONL files.

Features:
- Mechanical mode (default): deterministic merge using updated_at timestamps
- Closed status wins over open
- Higher priority (lower number) wins
- Notes are concatenated when different
- Dependencies are unioned
- Dry-run mode to preview changes
- JSON output for agent integration
- Automatic backup creation before changes

The command defaults to resolving .beads/beads.jsonl but accepts any file path.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

cmd/bd/main.go

@@ -310,6 +310,7 @@ var rootCmd = &cobra.Command{
 			"prime",
 			"quickstart",
 			"repair",
+			"resolve-conflicts",
 			"setup",
 			"version",
 			"zsh",

cmd/bd/resolve_conflicts.go

@@ -0,0 +1,552 @@
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/steveyegge/beads/internal/merge"
+	"github.com/steveyegge/beads/internal/ui"
+)
+
+var resolveConflictsCmd = &cobra.Command{
+	Use:     "resolve-conflicts [file]",
+	GroupID: GroupMaintenance,
+	Short:   "Resolve git merge conflicts in JSONL files",
+	Long: `Resolve git merge conflict markers in beads JSONL files.
+
+When git merges fail to auto-resolve, JSONL files can end up with conflict
+markers (<<<<<<, =======, >>>>>>). This command parses those markers and
+resolves the conflicts using beads merge semantics.
+
+Modes:
+  mechanical (default)  Uses deterministic merge rules (updated_at wins, etc.)
+  interactive           Prompts for each conflict (not yet implemented)
+
+The file defaults to .beads/beads.jsonl if not specified.
+
+Examples:
+  bd resolve-conflicts                    # Resolve conflicts in .beads/beads.jsonl
+  bd resolve-conflicts --dry-run          # Show what would be resolved
+  bd resolve-conflicts custom.jsonl       # Resolve conflicts in custom file
+  bd resolve-conflicts --json             # Output results as JSON`,
+	Args: cobra.MaximumNArgs(1),
+	// PreRun disables PersistentPreRun for this command (no database needed)
+	PreRun: func(cmd *cobra.Command, args []string) {},
+	Run:    runResolveConflicts,
+}
+
+var (
+	resolveConflictsMode   string
+	resolveConflictsDryRun bool
+	resolveConflictsJSON   bool
+	resolveConflictsPath   string
+)
+
+func init() {
+	resolveConflictsCmd.Flags().StringVar(&resolveConflictsMode, "mode", "mechanical", "Resolution mode: mechanical, interactive")
+	resolveConflictsCmd.Flags().BoolVar(&resolveConflictsDryRun, "dry-run", false, "Show what would be resolved without making changes")
+	resolveConflictsCmd.Flags().BoolVar(&resolveConflictsJSON, "json", false, "Output results as JSON")
+	resolveConflictsCmd.Flags().StringVar(&resolveConflictsPath, "path", ".", "Path to repository with .beads directory")
+	rootCmd.AddCommand(resolveConflictsCmd)
+}
+
+// conflictRegion represents a single conflict in the file
+type conflictRegion struct {
+	StartLine int      // Line number where <<<<<<< starts
+	EndLine   int      // Line number where >>>>>>> ends
+	LeftSide  []string // Lines between <<<<<<< and =======
+	RightSide []string // Lines between ======= and >>>>>>>
+	LeftLabel string   // Label after <<<<<<< (e.g., "HEAD")
+	RightLabel string  // Label after >>>>>>> (e.g., "branch-name")
+}
+
+// resolveConflictsResult is the JSON output structure
+type resolveConflictsResult struct {
+	FilePath         string                   `json:"file_path"`
+	DryRun           bool                     `json:"dry_run"`
+	Mode             string                   `json:"mode"`
+	ConflictsFound   int                      `json:"conflicts_found"`
+	ConflictsResolved int                     `json:"conflicts_resolved"`
+	Status           string                   `json:"status"` // "success", "no_conflicts", "dry_run", "error"
+	BackupPath       string                   `json:"backup_path,omitempty"`
+	Error            string                   `json:"error,omitempty"`
+	Conflicts        []conflictResolutionInfo `json:"conflicts,omitempty"`
+}
+
+type conflictResolutionInfo struct {
+	LineRange  string `json:"line_range"`
+	LeftLabel  string `json:"left_label"`
+	RightLabel string `json:"right_label"`
+	Resolution string `json:"resolution"` // "merged", "left", "right", "both"
+	IssueID    string `json:"issue_id,omitempty"`
+}
+
+func runResolveConflicts(cmd *cobra.Command, args []string) {
+	// Determine file path
+	var filePath string
+	if len(args) > 0 {
+		filePath = args[0]
+	} else {
+		filePath = filepath.Join(resolveConflictsPath, ".beads", "beads.jsonl")
+	}
+
+	// Validate mode
+	if resolveConflictsMode != "mechanical" && resolveConflictsMode != "interactive" {
+		outputResolveError(filePath, fmt.Sprintf("invalid mode: %s (use 'mechanical' or 'interactive')", resolveConflictsMode))
+		os.Exit(1)
+	}
+
+	if resolveConflictsMode == "interactive" {
+		outputResolveError(filePath, "interactive mode not yet implemented")
+		os.Exit(1)
+	}
+
+	// Check file exists
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		outputResolveError(filePath, fmt.Sprintf("file not found: %s", filePath))
+		os.Exit(1)
+	}
+
+	// Read file content
+	content, err := os.ReadFile(filePath) // #nosec G304 -- user-provided path for conflict resolution
+	if err != nil {
+		outputResolveError(filePath, fmt.Sprintf("reading file: %v", err))
+		os.Exit(1)
+	}
+
+	// Parse conflicts
+	conflicts, cleanLines, err := parseConflicts(string(content))
+	if err != nil {
+		outputResolveError(filePath, fmt.Sprintf("parsing conflicts: %v", err))
+		os.Exit(1)
+	}
+
+	result := resolveConflictsResult{
+		FilePath:       filePath,
+		DryRun:         resolveConflictsDryRun,
+		Mode:           resolveConflictsMode,
+		ConflictsFound: len(conflicts),
+	}
+
+	// No conflicts case
+	if len(conflicts) == 0 {
+		result.Status = "no_conflicts"
+		if resolveConflictsJSON {
+			outputResolveJSON(result, 0)
+		}
+		fmt.Printf("%s No conflict markers found in %s\n", ui.RenderPass("✓"), filePath)
+		return
+	}
+
+	if !resolveConflictsJSON {
+		fmt.Printf("Found %d conflict region(s) in %s\n", len(conflicts), filePath)
+		if resolveConflictsDryRun {
+			fmt.Println("[DRY-RUN] No changes will be made")
+		}
+		fmt.Println()
+	}
+
+	// Resolve each conflict
+	var resolvedLines []string
+	resolvedLines = append(resolvedLines, cleanLines...)
+
+	for i, conflict := range conflicts {
+		resolution, info := resolveConflict(conflict, i+1)
+		result.Conflicts = append(result.Conflicts, info)
+
+		if !resolveConflictsJSON && !resolveConflictsDryRun {
+			fmt.Printf("  Conflict %d (lines %d-%d): %s\n", i+1, conflict.StartLine, conflict.EndLine, info.Resolution)
+		}
+
+		resolvedLines = append(resolvedLines, resolution...)
+		result.ConflictsResolved++
+	}
+
+	// Dry-run output
+	if resolveConflictsDryRun {
+		result.Status = "dry_run"
+		if resolveConflictsJSON {
+			outputResolveJSON(result, 0)
+		} else {
+			fmt.Printf("[DRY-RUN] Would resolve %d conflict(s)\n", len(conflicts))
+			for i, info := range result.Conflicts {
+				fmt.Printf("  %d. Lines %s: %s", i+1, info.LineRange, info.Resolution)
+				if info.IssueID != "" {
+					fmt.Printf(" (issue: %s)", info.IssueID)
+				}
+				fmt.Println()
+			}
+		}
+		return
+	}
+
+	// Create backup
+	backupPath := filePath + ".pre-resolve"
+	if err := copyFile(filePath, backupPath); err != nil {
+		outputResolveError(filePath, fmt.Sprintf("creating backup: %v", err))
+		os.Exit(1)
+	}
+	result.BackupPath = backupPath
+
+	if !resolveConflictsJSON {
+		fmt.Printf("  Backup created: %s\n", filepath.Base(backupPath))
+	}
+
+	// Write resolved content
+	output := strings.Join(resolvedLines, "\n")
+	if len(resolvedLines) > 0 {
+		output += "\n"
+	}
+	if err := os.WriteFile(filePath, []byte(output), 0644); err != nil { // #nosec G306 -- standard file permissions
+		outputResolveError(filePath, fmt.Sprintf("writing file: %v", err))
+		os.Exit(1)
+	}
+
+	result.Status = "success"
+	if resolveConflictsJSON {
+		outputResolveJSON(result, 0)
+	} else {
+		fmt.Println()
+		fmt.Printf("%s Resolved %d conflict(s) in %s\n", ui.RenderPass("✓"), len(conflicts), filepath.Base(filePath))
+		fmt.Printf("Backup preserved at: %s\n", filepath.Base(backupPath))
+	}
+}
+
+// parseConflicts extracts conflict regions and non-conflicted lines from content
+func parseConflicts(content string) ([]conflictRegion, []string, error) {
+	var conflicts []conflictRegion
+	var cleanLines []string
+
+	scanner := bufio.NewScanner(strings.NewReader(content))
+	lineNum := 0
+	var current *conflictRegion
+	inLeft := false
+	inRight := false
+
+	for scanner.Scan() {
+		lineNum++
+		line := scanner.Text()
+
+		// Detect conflict start
+		if strings.HasPrefix(line, "<<<<<<<") {
+			if current != nil {
+				return nil, nil, fmt.Errorf("nested conflict at line %d", lineNum)
+			}
+			current = &conflictRegion{
+				StartLine:  lineNum,
+				LeftLabel:  strings.TrimSpace(strings.TrimPrefix(line, "<<<<<<<")),
+			}
+			inLeft = true
+			continue
+		}
+
+		// Detect conflict separator
+		if strings.HasPrefix(line, "=======") && current != nil {
+			inLeft = false
+			inRight = true
+			continue
+		}
+
+		// Detect conflict end
+		if strings.HasPrefix(line, ">>>>>>>") && current != nil {
+			current.EndLine = lineNum
+			current.RightLabel = strings.TrimSpace(strings.TrimPrefix(line, ">>>>>>>"))
+			conflicts = append(conflicts, *current)
+			current = nil
+			inLeft = false
+			inRight = false
+			continue
+		}
+
+		// Collect lines
+		if current != nil {
+			if inLeft {
+				current.LeftSide = append(current.LeftSide, line)
+			} else if inRight {
+				current.RightSide = append(current.RightSide, line)
+			}
+		} else {
+			cleanLines = append(cleanLines, line)
+		}
+	}
+
+	if current != nil {
+		return nil, nil, fmt.Errorf("unclosed conflict starting at line %d", current.StartLine)
+	}
+
+	return conflicts, cleanLines, scanner.Err()
+}
+
+// resolveConflict resolves a single conflict region using merge semantics
+func resolveConflict(conflict conflictRegion, num int) ([]string, conflictResolutionInfo) {
+	info := conflictResolutionInfo{
+		LineRange:  fmt.Sprintf("%d-%d", conflict.StartLine, conflict.EndLine),
+		LeftLabel:  conflict.LeftLabel,
+		RightLabel: conflict.RightLabel,
+	}
+
+	// Try to parse left and right as JSON issues
+	var leftIssues, rightIssues []merge.Issue
+
+	for _, line := range conflict.LeftSide {
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+		var issue merge.Issue
+		if err := json.Unmarshal([]byte(line), &issue); err == nil {
+			issue.RawLine = line
+			leftIssues = append(leftIssues, issue)
+		}
+	}
+
+	for _, line := range conflict.RightSide {
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+		var issue merge.Issue
+		if err := json.Unmarshal([]byte(line), &issue); err == nil {
+			issue.RawLine = line
+			rightIssues = append(rightIssues, issue)
+		}
+	}
+
+	// If we couldn't parse as JSON, keep both sides
+	if len(leftIssues) == 0 && len(rightIssues) == 0 {
+		info.Resolution = "kept_both_unparseable"
+		var result []string
+		result = append(result, conflict.LeftSide...)
+		result = append(result, conflict.RightSide...)
+		return result, info
+	}
+
+	// If only one side has valid JSON, use that
+	if len(leftIssues) > 0 && len(rightIssues) == 0 {
+		info.Resolution = "left_only_valid"
+		if len(leftIssues) == 1 {
+			info.IssueID = leftIssues[0].ID
+		}
+		return conflict.LeftSide, info
+	}
+
+	if len(rightIssues) > 0 && len(leftIssues) == 0 {
+		info.Resolution = "right_only_valid"
+		if len(rightIssues) == 1 {
+			info.IssueID = rightIssues[0].ID
+		}
+		return conflict.RightSide, info
+	}
+
+	// Both sides have valid JSON - merge them
+	// Use the 3-way merge logic with empty base (both sides added the same issue)
+	var result []string
+	mergedIDs := make(map[string]bool)
+
+	for _, left := range leftIssues {
+		// Find matching right issue by ID
+		var matchingRight *merge.Issue
+		for i := range rightIssues {
+			if rightIssues[i].ID == left.ID {
+				matchingRight = &rightIssues[i]
+				break
+			}
+		}
+
+		if matchingRight != nil {
+			// Merge the two versions
+			merged := mergeIssueConflict(left, *matchingRight)
+			mergedJSON, err := json.Marshal(merged)
+			if err != nil {
+				// Fall back to left on marshal error
+				result = append(result, left.RawLine)
+			} else {
+				result = append(result, string(mergedJSON))
+			}
+			mergedIDs[left.ID] = true
+			info.IssueID = left.ID
+			info.Resolution = "merged"
+		} else {
+			// No matching right issue - keep left
+			result = append(result, left.RawLine)
+		}
+	}
+
+	// Add any right issues that weren't merged
+	for _, right := range rightIssues {
+		if !mergedIDs[right.ID] {
+			result = append(result, right.RawLine)
+		}
+	}
+
+	if info.Resolution == "" {
+		info.Resolution = "merged_multiple"
+	}
+
+	return result, info
+}
+
+// mergeIssueConflict merges two conflicting issue versions
+// Uses similar logic to internal/merge but simplified for conflict resolution
+func mergeIssueConflict(left, right merge.Issue) merge.Issue {
+	result := merge.Issue{
+		ID:        left.ID,
+		CreatedAt: left.CreatedAt,
+		CreatedBy: left.CreatedBy,
+	}
+
+	// Title: prefer later updated_at
+	result.Title = pickByUpdatedAt(left.Title, right.Title, left.UpdatedAt, right.UpdatedAt)
+
+	// Description: prefer later updated_at
+	result.Description = pickByUpdatedAt(left.Description, right.Description, left.UpdatedAt, right.UpdatedAt)
+
+	// Notes: concatenate if different
+	if left.Notes == right.Notes {
+		result.Notes = left.Notes
+	} else if left.Notes == "" {
+		result.Notes = right.Notes
+	} else if right.Notes == "" {
+		result.Notes = left.Notes
+	} else {
+		result.Notes = left.Notes + "\n\n---\n\n" + right.Notes
+	}
+
+	// Status: closed wins
+	if left.Status == "closed" || right.Status == "closed" {
+		result.Status = "closed"
+	} else if left.Status == "tombstone" || right.Status == "tombstone" {
+		result.Status = "tombstone"
+	} else {
+		result.Status = pickByUpdatedAt(left.Status, right.Status, left.UpdatedAt, right.UpdatedAt)
+	}
+
+	// Priority: lower number (higher priority) wins
+	if left.Priority != 0 && right.Priority != 0 {
+		if left.Priority < right.Priority {
+			result.Priority = left.Priority
+		} else {
+			result.Priority = right.Priority
+		}
+	} else if left.Priority != 0 {
+		result.Priority = left.Priority
+	} else {
+		result.Priority = right.Priority
+	}
+
+	// IssueType: prefer left
+	if left.IssueType != "" {
+		result.IssueType = left.IssueType
+	} else {
+		result.IssueType = right.IssueType
+	}
+
+	// UpdatedAt: max
+	result.UpdatedAt = maxTimeStr(left.UpdatedAt, right.UpdatedAt)
+
+	// ClosedAt: max (if status is closed)
+	if result.Status == "closed" {
+		result.ClosedAt = maxTimeStr(left.ClosedAt, right.ClosedAt)
+		// CloseReason and ClosedBySession from whichever has later ClosedAt
+		if isTimeAfterStr(left.ClosedAt, right.ClosedAt) {
+			result.CloseReason = left.CloseReason
+			result.ClosedBySession = left.ClosedBySession
+		} else {
+			result.CloseReason = right.CloseReason
+			result.ClosedBySession = right.ClosedBySession
+		}
+	}
+
+	// Dependencies: union
+	depMap := make(map[string]merge.Dependency)
+	for _, dep := range left.Dependencies {
+		key := fmt.Sprintf("%s:%s:%s", dep.IssueID, dep.DependsOnID, dep.Type)
+		depMap[key] = dep
+	}
+	for _, dep := range right.Dependencies {
+		key := fmt.Sprintf("%s:%s:%s", dep.IssueID, dep.DependsOnID, dep.Type)
+		if _, exists := depMap[key]; !exists {
+			depMap[key] = dep
+		}
+	}
+	for _, dep := range depMap {
+		result.Dependencies = append(result.Dependencies, dep)
+	}
+
+	// Tombstone fields
+	if result.Status == "tombstone" {
+		if isTimeAfterStr(left.DeletedAt, right.DeletedAt) {
+			result.DeletedAt = left.DeletedAt
+			result.DeletedBy = left.DeletedBy
+			result.DeleteReason = left.DeleteReason
+			result.OriginalType = left.OriginalType
+		} else {
+			result.DeletedAt = right.DeletedAt
+			result.DeletedBy = right.DeletedBy
+			result.DeleteReason = right.DeleteReason
+			result.OriginalType = right.OriginalType
+		}
+	}
+
+	return result
+}
+
+func pickByUpdatedAt(left, right, leftTime, rightTime string) string {
+	if left == right {
+		return left
+	}
+	if isTimeAfterStr(leftTime, rightTime) {
+		return left
+	}
+	return right
+}
+
+func maxTimeStr(t1, t2 string) string {
+	if t1 == "" {
+		return t2
+	}
+	if t2 == "" {
+		return t1
+	}
+	if isTimeAfterStr(t1, t2) {
+		return t1
+	}
+	return t2
+}
+
+func isTimeAfterStr(t1, t2 string) bool {
+	if t1 == "" {
+		return false
+	}
+	if t2 == "" {
+		return true
+	}
+	// Simple string comparison works for RFC3339 timestamps
+	return t1 > t2
+}
+
+func outputResolveError(filePath, errMsg string) {
+	if resolveConflictsJSON {
+		result := resolveConflictsResult{
+			FilePath: filePath,
+			Status:   "error",
+			Error:    errMsg,
+		}
+		outputResolveJSON(result, 1)
+	} else {
+		fmt.Fprintf(os.Stderr, "Error: %s\n", errMsg)
+	}
+}
+
+func outputResolveJSON(result resolveConflictsResult, exitCode int) {
+	data, err := json.MarshalIndent(result, "", "  ")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, `{"error": "failed to marshal JSON: %v"}`, err)
+		os.Exit(1)
+	}
+	fmt.Println(string(data))
+	os.Exit(exitCode)
+}

cmd/bd/resolve_conflicts_test.go

@@ -0,0 +1,423 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/steveyegge/beads/internal/merge"
+)
+
+func TestParseConflicts(t *testing.T) {
+	tests := []struct {
+		name           string
+		content        string
+		wantConflicts  int
+		wantCleanLines int
+		wantErr        bool
+	}{
+		{
+			name: "no conflicts",
+			content: `{"id":"bd-1","title":"Issue 1"}
+{"id":"bd-2","title":"Issue 2"}`,
+			wantConflicts:  0,
+			wantCleanLines: 2,
+			wantErr:        false,
+		},
+		{
+			name: "single conflict",
+			content: `{"id":"bd-1","title":"Issue 1"}
+<<<<<<< HEAD
+{"id":"bd-2","title":"Issue 2 local"}
+=======
+{"id":"bd-2","title":"Issue 2 remote"}
+>>>>>>> branch
+{"id":"bd-3","title":"Issue 3"}`,
+			wantConflicts:  1,
+			wantCleanLines: 2,
+			wantErr:        false,
+		},
+		{
+			name: "multiple conflicts",
+			content: `<<<<<<< HEAD
+{"id":"bd-1","title":"Local 1"}
+=======
+{"id":"bd-1","title":"Remote 1"}
+>>>>>>> branch
+{"id":"bd-2","title":"Clean line"}
+<<<<<<< HEAD
+{"id":"bd-3","title":"Local 3"}
+=======
+{"id":"bd-3","title":"Remote 3"}
+>>>>>>> other-branch`,
+			wantConflicts:  2,
+			wantCleanLines: 1,
+			wantErr:        false,
+		},
+		{
+			name: "unclosed conflict",
+			content: `<<<<<<< HEAD
+{"id":"bd-1","title":"Local"}
+=======
+{"id":"bd-1","title":"Remote"}`,
+			wantConflicts:  0,
+			wantCleanLines: 0,
+			wantErr:        true,
+		},
+		{
+			name: "nested conflict error",
+			content: `<<<<<<< HEAD
+<<<<<<< HEAD
+{"id":"bd-1","title":"Nested"}
+=======
+{"id":"bd-1","title":"Remote"}
+>>>>>>> branch`,
+			wantConflicts:  0,
+			wantCleanLines: 0,
+			wantErr:        true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			conflicts, cleanLines, err := parseConflicts(tt.content)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Error("Expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				return
+			}
+
+			if len(conflicts) != tt.wantConflicts {
+				t.Errorf("Got %d conflicts, want %d", len(conflicts), tt.wantConflicts)
+			}
+
+			if len(cleanLines) != tt.wantCleanLines {
+				t.Errorf("Got %d clean lines, want %d", len(cleanLines), tt.wantCleanLines)
+			}
+		})
+	}
+}
+
+func TestParseConflictsLabels(t *testing.T) {
+	content := `<<<<<<< HEAD
+{"id":"bd-1","title":"Local"}
+=======
+{"id":"bd-1","title":"Remote"}
+>>>>>>> feature-branch`
+
+	conflicts, _, err := parseConflicts(content)
+	if err != nil {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+
+	if len(conflicts) != 1 {
+		t.Fatalf("Expected 1 conflict, got %d", len(conflicts))
+	}
+
+	if conflicts[0].LeftLabel != "HEAD" {
+		t.Errorf("Expected left label 'HEAD', got %q", conflicts[0].LeftLabel)
+	}
+
+	if conflicts[0].RightLabel != "feature-branch" {
+		t.Errorf("Expected right label 'feature-branch', got %q", conflicts[0].RightLabel)
+	}
+
+	if len(conflicts[0].LeftSide) != 1 {
+		t.Errorf("Expected 1 left line, got %d", len(conflicts[0].LeftSide))
+	}
+
+	if len(conflicts[0].RightSide) != 1 {
+		t.Errorf("Expected 1 right line, got %d", len(conflicts[0].RightSide))
+	}
+}
+
+func TestResolveConflict(t *testing.T) {
+	tests := []struct {
+		name       string
+		conflict   conflictRegion
+		wantIssueID string
+		wantResContains string
+	}{
+		{
+			name: "merge same issue different titles",
+			conflict: conflictRegion{
+				StartLine: 1,
+				EndLine:   5,
+				LeftSide:  []string{`{"id":"bd-1","title":"Local Title","updated_at":"2024-01-02T00:00:00Z"}`},
+				RightSide: []string{`{"id":"bd-1","title":"Remote Title","updated_at":"2024-01-01T00:00:00Z"}`},
+				LeftLabel: "HEAD",
+				RightLabel: "branch",
+			},
+			wantIssueID:     "bd-1",
+			wantResContains: "merged",
+		},
+		{
+			name: "left only valid JSON",
+			conflict: conflictRegion{
+				StartLine: 1,
+				EndLine:   5,
+				LeftSide:  []string{`{"id":"bd-1","title":"Valid"}`},
+				RightSide: []string{`not valid json`},
+				LeftLabel: "HEAD",
+				RightLabel: "branch",
+			},
+			wantIssueID:     "bd-1",
+			wantResContains: "left_only_valid",
+		},
+		{
+			name: "right only valid JSON",
+			conflict: conflictRegion{
+				StartLine: 1,
+				EndLine:   5,
+				LeftSide:  []string{`invalid json here`},
+				RightSide: []string{`{"id":"bd-2","title":"Valid"}`},
+				LeftLabel: "HEAD",
+				RightLabel: "branch",
+			},
+			wantIssueID:     "bd-2",
+			wantResContains: "right_only_valid",
+		},
+		{
+			name: "both unparseable",
+			conflict: conflictRegion{
+				StartLine: 1,
+				EndLine:   5,
+				LeftSide:  []string{`not json`},
+				RightSide: []string{`also not json`},
+				LeftLabel: "HEAD",
+				RightLabel: "branch",
+			},
+			wantIssueID:     "",
+			wantResContains: "kept_both_unparseable",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, info := resolveConflict(tt.conflict, 1)
+
+			if tt.wantIssueID != "" && info.IssueID != tt.wantIssueID {
+				t.Errorf("Got issue ID %q, want %q", info.IssueID, tt.wantIssueID)
+			}
+
+			if !strings.Contains(info.Resolution, tt.wantResContains) {
+				t.Errorf("Resolution %q doesn't contain %q", info.Resolution, tt.wantResContains)
+			}
+		})
+	}
+}
+
+func TestMergeIssueConflict(t *testing.T) {
+	t.Run("title picks later updated_at", func(t *testing.T) {
+		left := merge.Issue{
+			ID:        "bd-1",
+			Title:     "Old Title",
+			UpdatedAt: "2024-01-01T00:00:00Z",
+		}
+		right := merge.Issue{
+			ID:        "bd-1",
+			Title:     "New Title",
+			UpdatedAt: "2024-01-02T00:00:00Z",
+		}
+
+		result := mergeIssueConflict(left, right)
+
+		if result.Title != "New Title" {
+			t.Errorf("Expected title 'New Title', got %q", result.Title)
+		}
+	})
+
+	t.Run("closed status wins", func(t *testing.T) {
+		left := merge.Issue{
+			ID:     "bd-1",
+			Status: "open",
+		}
+		right := merge.Issue{
+			ID:     "bd-1",
+			Status: "closed",
+		}
+
+		result := mergeIssueConflict(left, right)
+
+		if result.Status != "closed" {
+			t.Errorf("Expected status 'closed', got %q", result.Status)
+		}
+	})
+
+	t.Run("higher priority wins", func(t *testing.T) {
+		left := merge.Issue{
+			ID:       "bd-1",
+			Priority: 2,
+		}
+		right := merge.Issue{
+			ID:       "bd-1",
+			Priority: 1,
+		}
+
+		result := mergeIssueConflict(left, right)
+
+		if result.Priority != 1 {
+			t.Errorf("Expected priority 1, got %d", result.Priority)
+		}
+	})
+
+	t.Run("notes concatenate when different", func(t *testing.T) {
+		left := merge.Issue{
+			ID:    "bd-1",
+			Notes: "Note A",
+		}
+		right := merge.Issue{
+			ID:    "bd-1",
+			Notes: "Note B",
+		}
+
+		result := mergeIssueConflict(left, right)
+
+		if !strings.Contains(result.Notes, "Note A") || !strings.Contains(result.Notes, "Note B") {
+			t.Errorf("Expected concatenated notes, got %q", result.Notes)
+		}
+	})
+
+	t.Run("dependencies union", func(t *testing.T) {
+		left := merge.Issue{
+			ID: "bd-1",
+			Dependencies: []merge.Dependency{
+				{IssueID: "bd-1", DependsOnID: "bd-2", Type: "blocks"},
+			},
+		}
+		right := merge.Issue{
+			ID: "bd-1",
+			Dependencies: []merge.Dependency{
+				{IssueID: "bd-1", DependsOnID: "bd-3", Type: "blocks"},
+			},
+		}
+
+		result := mergeIssueConflict(left, right)
+
+		if len(result.Dependencies) != 2 {
+			t.Errorf("Expected 2 dependencies, got %d", len(result.Dependencies))
+		}
+	})
+}
+
+func TestTimeHelpers(t *testing.T) {
+	t.Run("isTimeAfterStr", func(t *testing.T) {
+		tests := []struct {
+			t1, t2 string
+			want   bool
+		}{
+			{"2024-01-02T00:00:00Z", "2024-01-01T00:00:00Z", true},
+			{"2024-01-01T00:00:00Z", "2024-01-02T00:00:00Z", false},
+			{"2024-01-01T00:00:00Z", "2024-01-01T00:00:00Z", false},
+			{"2024-01-01T00:00:00Z", "", true},
+			{"", "2024-01-01T00:00:00Z", false},
+			{"", "", false},
+		}
+
+		for _, tt := range tests {
+			got := isTimeAfterStr(tt.t1, tt.t2)
+			if got != tt.want {
+				t.Errorf("isTimeAfterStr(%q, %q) = %v, want %v", tt.t1, tt.t2, got, tt.want)
+			}
+		}
+	})
+
+	t.Run("maxTimeStr", func(t *testing.T) {
+		tests := []struct {
+			t1, t2, want string
+		}{
+			{"2024-01-02T00:00:00Z", "2024-01-01T00:00:00Z", "2024-01-02T00:00:00Z"},
+			{"2024-01-01T00:00:00Z", "2024-01-02T00:00:00Z", "2024-01-02T00:00:00Z"},
+			{"2024-01-01T00:00:00Z", "", "2024-01-01T00:00:00Z"},
+			{"", "2024-01-01T00:00:00Z", "2024-01-01T00:00:00Z"},
+			{"", "", ""},
+		}
+
+		for _, tt := range tests {
+			got := maxTimeStr(tt.t1, tt.t2)
+			if got != tt.want {
+				t.Errorf("maxTimeStr(%q, %q) = %q, want %q", tt.t1, tt.t2, got, tt.want)
+			}
+		}
+	})
+
+	t.Run("pickByUpdatedAt", func(t *testing.T) {
+		tests := []struct {
+			left, right, leftTime, rightTime, want string
+		}{
+			{"A", "B", "2024-01-02T00:00:00Z", "2024-01-01T00:00:00Z", "A"},
+			{"A", "B", "2024-01-01T00:00:00Z", "2024-01-02T00:00:00Z", "B"},
+			{"Same", "Same", "2024-01-01T00:00:00Z", "2024-01-02T00:00:00Z", "Same"},
+		}
+
+		for _, tt := range tests {
+			got := pickByUpdatedAt(tt.left, tt.right, tt.leftTime, tt.rightTime)
+			if got != tt.want {
+				t.Errorf("pickByUpdatedAt(%q, %q, ...) = %q, want %q", tt.left, tt.right, got, tt.want)
+			}
+		}
+	})
+}
+
+func TestResolveConflictsEndToEnd(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "bd-resolve-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	// Create a file with conflicts
+	conflictFile := filepath.Join(tmpDir, "test.jsonl")
+	content := `{"id":"bd-1","title":"Clean issue"}
+<<<<<<< HEAD
+{"id":"bd-2","title":"Local version","updated_at":"2024-01-02T00:00:00Z"}
+=======
+{"id":"bd-2","title":"Remote version","updated_at":"2024-01-01T00:00:00Z"}
+>>>>>>> remote-branch
+{"id":"bd-3","title":"Another clean issue"}`
+
+	if err := os.WriteFile(conflictFile, []byte(content), 0644); err != nil {
+		t.Fatalf("Failed to write test file: %v", err)
+	}
+
+	// Parse conflicts
+	conflicts, cleanLines, err := parseConflicts(content)
+	if err != nil {
+		t.Fatalf("Failed to parse conflicts: %v", err)
+	}
+
+	if len(conflicts) != 1 {
+		t.Errorf("Expected 1 conflict, got %d", len(conflicts))
+	}
+
+	if len(cleanLines) != 2 {
+		t.Errorf("Expected 2 clean lines, got %d", len(cleanLines))
+	}
+
+	// Resolve the conflict
+	resolved, info := resolveConflict(conflicts[0], 1)
+	if info.Resolution != "merged" {
+		t.Errorf("Expected resolution 'merged', got %q", info.Resolution)
+	}
+
+	if info.IssueID != "bd-2" {
+		t.Errorf("Expected issue ID 'bd-2', got %q", info.IssueID)
+	}
+
+	// The resolved content should contain the local title (later updated_at)
+	if len(resolved) != 1 {
+		t.Fatalf("Expected 1 resolved line, got %d", len(resolved))
+	}
+
+	if !strings.Contains(resolved[0], "Local version") {
+		t.Errorf("Expected resolved content to contain 'Local version', got %q", resolved[0])
+	}
+}