fix: merge conflicts not visible when changes are staged

.github/workflows/auto-merge-release.yml

@@ -1,31 +1,62 @@
 name: Auto-merge release-please PR
 
 on:
-  pull_request:
+  # Triggers after the Release workflow completes on main.
+  # workflow_run always runs in the default-branch context, so it is never
+  # blocked by the "first-time contributor" approval gate.
+  workflow_run:
+    workflows: ["Release"]
+    types: [completed]
     branches: [main]
-    types: [opened, synchronize, reopened]
 
 permissions:
   contents: write
   pull-requests: write
 
 jobs:
   auto-merge:
-    # Only run on release-please PRs
-    if: github.actor == 'github-actions[bot]' && startsWith(github.head_ref, 'release-please--')
     runs-on: macos-26
+    # Only proceed when the Release workflow succeeded
+    if: github.event.workflow_run.conclusion == 'success'
     steps:
+      - name: Find open release-please PR
+        id: find-pr
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          PR_NUMBER=$(gh pr list \
+            --repo "${{ github.repository }}" \
+            --head "release-please--branches--main" \
+            --state open \
+            --json number \
+            --jq '.[0].number // empty')
+
+          if [[ -z "${PR_NUMBER}" ]]; then
+            echo "No open release-please PR found; nothing to do."
+            echo "found=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "Found release-please PR #${PR_NUMBER}"
+            echo "found=true" >> "$GITHUB_OUTPUT"
+            echo "number=${PR_NUMBER}" >> "$GITHUB_OUTPUT"
+          fi
+
       - uses: actions/checkout@v4
+        if: steps.find-pr.outputs.found == 'true'
+        with:
+          ref: release-please--branches--main
 
       - name: Build
+        if: steps.find-pr.outputs.found == 'true'
         run: swift build
 
       - name: Run tests
+        if: steps.find-pr.outputs.found == 'true'
         run: swift run GitKitChecks
 
       - name: Approve and auto-merge
+        if: steps.find-pr.outputs.found == 'true'
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          gh pr review "${{ github.event.pull_request.number }}" --approve
-          gh pr merge "${{ github.event.pull_request.number }}" --squash --auto
+          gh pr review "${{ steps.find-pr.outputs.number }}" --approve
+          gh pr merge "${{ steps.find-pr.outputs.number }}" --squash --auto

Sources/GitKit/Models/FileStatus.swift

@@ -57,8 +57,14 @@ public struct WorkingTreeStatus: Sendable {
     public let isDetached: Bool
     public let files: [FileStatus]
 
-    public var stagedFiles: [FileStatus] { files.filter(\.isStaged) }
-    public var unstagedFiles: [FileStatus] { files.filter { $0.hasUnstagedChanges || $0.isUntracked } }
+    /// Conflicted (unmerged) files. Surfaced separately so they don't masquerade as ordinary
+    /// staged/unstaged edits — an unmerged entry reports both an index and a worktree state.
+    public var conflictedFiles: [FileStatus] { files.filter(\.isConflicted) }
+    public var stagedFiles: [FileStatus] { files.filter { $0.isStaged && !$0.isConflicted } }
+    public var unstagedFiles: [FileStatus] {
+        files.filter { !$0.isConflicted && ($0.hasUnstagedChanges || $0.isUntracked) }
+    }
+    public var hasConflicts: Bool { files.contains(where: \.isConflicted) }
     public var hasChanges: Bool { !files.isEmpty }
 
     public init(

Sources/Gitify/Views/WorkingTreeView.swift

@@ -127,9 +127,11 @@ struct WorkingTreeView: View {
 
     private func fileList(_ status: WorkingTreeStatus) -> some View {
         // Build a flat ordered list of FileSelection entries for shift-click range computation.
+        let conflictedFiles = status.conflictedFiles.filter(matches)
         let stagedFiles = status.stagedFiles.filter(matches)
         let unstagedFiles = status.unstagedFiles.filter(matches)
         let orderedSelections: [FileSelection] =
+            conflictedFiles.map { FileSelection(path: $0.path, staged: false) } +
             stagedFiles.map { FileSelection(path: $0.path, staged: true) } +
             unstagedFiles.map { FileSelection(path: $0.path, staged: false) }
 
@@ -138,6 +140,24 @@ struct WorkingTreeView: View {
         let unstagedPeers = selectedUnstagedFiles(in: status)
 
         return List {
+            if !conflictedFiles.isEmpty {
+                Section {
+                    ForEach(conflictedFiles) { file in
+                        ConflictFileRow(file: file, viewModel: viewModel,
+                                        isSelected: selection.contains(FileSelection(path: file.path, staged: false)),
+                                        onResolveInEditor: { conflictTarget = ConflictTarget(path: file.path) },
+                                        onClick: { mods in
+                                            handleRowClick(FileSelection(path: file.path, staged: false),
+                                                           file: file, orderedSelections: orderedSelections, modifiers: mods)
+                                        })
+                    }
+                } header: {
+                    sectionHeader("Conflicts", count: conflictedFiles.count) {
+                        Text("resolve before committing")
+                            .font(.caption).foregroundStyle(.orange)
+                    }
+                }
+            }
             if !stagedFiles.isEmpty {
                 Section {
                     ForEach(stagedFiles) { file in
@@ -361,6 +381,57 @@ private struct StagingFileRow: View {
     }
 }
 
+/// A conflicted-file row with always-visible resolution actions, so a merge conflict is
+/// obvious and fixable without discovering a hidden context menu.
+private struct ConflictFileRow: View {
+    let file: FileStatus
+    @Bindable var viewModel: RepositoryViewModel
+    let isSelected: Bool
+    var onResolveInEditor: () -> Void
+    var onClick: (NSEvent.ModifierFlags) -> Void
+
+    var body: some View {
+        HStack(spacing: 8) {
+            StatusBadge(file: file)
+            VStack(alignment: .leading, spacing: 1) {
+                Text(URL(fileURLWithPath: file.path).lastPathComponent)
+                Text(conflictDescription).font(.caption).foregroundStyle(.orange).lineLimit(1)
+            }
+            Spacer()
+            Button("Resolve…") { onResolveInEditor() }
+                .buttonStyle(.borderless).font(.caption)
+            Menu {
+                Button("Take Ours (current branch)") { Task { await viewModel.resolveConflict(file, useOurs: true) } }
+                Button("Take Theirs (incoming)") { Task { await viewModel.resolveConflict(file, useOurs: false) } }
+                Divider()
+                Button("Mark Resolved") { Task { await viewModel.markResolved(file) } }
+            } label: {
+                Image(systemName: "ellipsis.circle")
+            }
+            .menuStyle(.borderlessButton)
+            .fixedSize()
+        }
+        .padding(.vertical, 2)
+        .listRowBackground(isSelected ? Color.accentColor.opacity(0.2) : Color.clear)
+        .contentShape(Rectangle())
+        .onTapGesture { onClick(currentModifiers()) }
+    }
+
+    /// Human-readable conflict kind derived from the unmerged XY state pair.
+    private var conflictDescription: String {
+        switch (file.indexState, file.worktreeState) {
+        case (.deleted, .deleted): return "both deleted"
+        case (.added, .updatedButUnmerged): return "added by us"
+        case (.updatedButUnmerged, .added): return "added by them"
+        case (.deleted, .updatedButUnmerged): return "deleted by us"
+        case (.updatedButUnmerged, .deleted): return "deleted by them"
+        case (.added, .added): return "both added"
+        case (.updatedButUnmerged, .updatedButUnmerged): return "both modified"
+        default: return "conflicted"
+        }
+    }
+}
+
 /// Colored M/A/D/R/?? badge mirroring git's status letters.
 struct StatusBadge: View {
     let file: FileStatus