fix: detect GitHub rate limit and show toast with 5-minute cooldown

When batchPRLookup hits a rate limit error from the GitHub GraphQL API,
throw GhCliError.rateLimited instead of silently returning empty results.
BoardStore catches this and:
- Shows an error toast so the user knows PR lookups are paused
- Sets a 5-minute cooldown (ghRateLimitedUntil) to avoid hammering the API
- Also increases minimum active interval from 0s to 30s to reduce API pressure

Author: rogeriochaves

Sources/KanbanCodeCore/Adapters/Git/GhCliAdapter.swift

@@ -269,6 +269,11 @@ public final class GhCliAdapter: PRTrackerPort, @unchecked Sendable {
               let root = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
               let dataObj = root["data"] as? [String: Any],
               let repo = dataObj["repository"] as? [String: Any] else {
+            let combined = result.stderr + result.stdout
+            if combined.localizedCaseInsensitiveContains("rate limit") || combined.contains("RATE_LIMITED") {
+                KanbanCodeLog.warn("gh", "batchPRLookup hit rate limit")
+                throw GhCliError.rateLimited
+            }
             KanbanCodeLog.warn("gh", "batchPRLookup GraphQL failed: \(result.stderr.prefix(200))")
             return ([:], [:])
         }
@@ -373,6 +378,17 @@ public final class GhCliAdapter: PRTrackerPort, @unchecked Sendable {
     }
 }
 
+public enum GhCliError: Error, LocalizedError {
+    case rateLimited
+
+    public var errorDescription: String? {
+        switch self {
+        case .rateLimited:
+            return "GitHub API rate limit exceeded — pausing PR lookups for 5 minutes"
+        }
+    }
+}
+
 /// A GitHub issue for the backlog.
 public struct GitHubIssue: Identifiable, Sendable {
     public var id: Int { number }

Sources/KanbanCodeCore/UseCases/BoardStore.swift

@@ -285,6 +285,7 @@ public enum Reducer {
             }
             link.tmuxLink = TmuxLink(sessionName: tmuxName, extraSessions: extras.isEmpty ? nil : extras)
             link.column = .inProgress
+            link.manualOverrides.column = false // Let automatic assignment take over
             link.isLaunching = true
             link.updatedAt = .now
             state.links[cardId] = link
@@ -303,6 +304,7 @@ public enum Reducer {
             }
             link.tmuxLink = TmuxLink(sessionName: tmuxName, extraSessions: extras.isEmpty ? nil : extras)
             link.column = .inProgress
+            link.manualOverrides.column = false // Let automatic assignment take over
             link.isLaunching = true
             link.updatedAt = .now
             state.links[cardId] = link
@@ -882,6 +884,7 @@ public final class BoardStore: @unchecked Sendable {
     // Dependencies for reconciliation
     private var isReconciling = false
     private var lastGHLookup: ContinuousClock.Instant = .now - .seconds(600)
+    private var ghRateLimitedUntil: ContinuousClock.Instant = .now
     public var appIsActive: Bool = true
     private let discovery: SessionDiscovery
     private let coordinationStore: CoordinationStore
@@ -1082,15 +1085,16 @@ public final class BoardStore: @unchecked Sendable {
             }
 
             // Fetch PR data via targeted GraphQL — concurrent across repos (max 5)
-            // Throttle: every reconcile cycle when active, every 5min when backgrounded/hidden.
-            let ghInterval: Duration = appIsActive ? .seconds(0) : .seconds(300)
+            // Throttle: 30s when active, 5min when backgrounded/hidden, 5min after rate limit.
+            let ghInterval: Duration = ghRateLimitedUntil > .now ? .seconds(300)
+                : appIsActive ? .seconds(30) : .seconds(300)
             let shouldFetchPRs = ContinuousClock.now - lastGHLookup >= ghInterval
             var pullRequests: [String: PullRequest] = [:]  // branch → PR for reconciler
             var prsByRepoAndNumber: [String: [Int: PullRequest]] = [:]  // repo → number → PR
             if let ghAdapter, shouldFetchPRs {
                 let t = ContinuousClock.now
                 let allRepos = Set(branchesByRepo.keys).union(prNumbersByRepo.keys)
-                typealias PRResult = (String, [String: PullRequest], [Int: PullRequest])
+                typealias PRResult = (String, [String: PullRequest], [Int: PullRequest], Bool)
                 let results: [PRResult] = await withTaskGroup(of: PRResult.self) { group in
                     var pending = 0
                     var collected: [PRResult] = []
@@ -1107,27 +1111,39 @@ public final class BoardStore: @unchecked Sendable {
 
                         group.addTask {
                             let tBatch = ContinuousClock.now
-                            let (byBranch, byNumber) = (try? await ghAdapter.batchPRLookup(
-                                repoRoot: repoRoot, branches: branches, prNumbers: numbers
-                            )) ?? ([:], [:])
-                            let repoName = (repoRoot as NSString).lastPathComponent
-                            KanbanCodeLog.info("reconcile", "  batchPRLookup(\(repoName)): \(tBatch.duration(to: .now)) (\(branches.count) branches, \(numbers.count) PRs)")
-                            return (repoRoot, byBranch, byNumber)
+                            do {
+                                let (byBranch, byNumber) = try await ghAdapter.batchPRLookup(
+                                    repoRoot: repoRoot, branches: branches, prNumbers: numbers
+                                )
+                                let repoName = (repoRoot as NSString).lastPathComponent
+                                KanbanCodeLog.info("reconcile", "  batchPRLookup(\(repoName)): \(tBatch.duration(to: .now)) (\(branches.count) branches, \(numbers.count) PRs)")
+                                return (repoRoot, byBranch, byNumber, false)
+                            } catch is GhCliError {
+                                return (repoRoot, [:], [:], true)
+                            } catch {
+                                return (repoRoot, [:], [:], false)
+                            }
                         }
                         pending += 1
                     }
                     for await result in group { collected.append(result) }
                     return collected
                 }
 
-                for (repoRoot, byBranch, byNumber) in results {
+                var hitRateLimit = false
+                for (repoRoot, byBranch, byNumber, rateLimited) in results {
+                    if rateLimited { hitRateLimit = true }
                     for (branch, pr) in byBranch {
                         pullRequests[branch] = pr
                     }
                     if !byNumber.isEmpty {
                         prsByRepoAndNumber[repoRoot] = byNumber
                     }
                 }
+                if hitRateLimit {
+                    ghRateLimitedUntil = .now + .seconds(300)
+                    dispatch(.setError("GitHub API rate limit exceeded — pausing PR lookups for 5 minutes"))
+                }
                 let totalByNumber = prsByRepoAndNumber.values.reduce(0) { $0 + $1.count }
                 KanbanCodeLog.info("reconcile", "PR lookup: \(t.duration(to: .now)) (\(pullRequests.count) by branch, \(totalByNumber) by number, \(allRepos.count) repos)")
                 lastGHLookup = .now