Build HistoryStore — opt-in git and mode detection

The pro-m1 foundation card. SwiftGitX 0.4.0 (bundled libgit2, the
pathfinder's pin) joins the one target; new Kanban/Git/ holds
BoardGitMode (pure nearest-.git-wins detection, .git-as-file counts,
NSString ancestor walk), HistoryStore (@MainActor @Observable;
compose() is the tier gate — free tier gets no object, no detection,
no stat), GitRepository (scope-confined SwiftGitX handles: create =
init + HEAD forced to main + whole-tree "Initial board state" commit;
branch reads incl. unborn/detached; path-history ranks), GitIdentity
(derived default as a pure function + repo-local config reader — not
libgit2's merged ladder), and GitPathHistory (Mutex-guarded lazy
ranker). beginSession composes the git state beside the tier and
feeds BoardStore.makeIdentityHistoryRanker; git-mode loads pass the
git-backed IdentityHistoryRanker to BoardLoader. The popover's git
slot resolves a pure five-way matrix: free tier unchanged (absent /
BoardGitNote), Pro mode-aware — Add Git on mode none, honest prose on
repo-nested, read-only branch line on git. Provider binding
unchanged: both tiers still bind native until the undo/redo card.

42 new tests across 8 suites, all repositories built through bundled
libgit2; InertGitTests untouched and green. 2194 tests / 375 suites.

Claude-Session: https://claude.ai/code/session_01SR4XGjmBE16ZUYWpfFHXwY

Kanban/App/AppModel.swift

@@ -341,6 +341,36 @@ public final class AppModel {
         /// whatever the entitlement happens to say when the sidebar renders.
         public let tier: Tier
 
+        /// **This board's git state** (06-history-undo.md ▸ Rules; 02-architecture.md ▸ Components
+        /// ▸ HistoryStore) — the detected mode, the repository behind it in git mode, and the
+        /// add-git action the popover offers on a board that has none.
+        ///
+        /// `nil` under the free tier, and that is the inert posture made structural rather than
+        /// remembered: with no object there is nothing to consult, nothing to detect with, and no
+        /// path by which a free-tier session could touch `.git` (12-editions.md ▸ The free tier and
+        /// `.git`). `HistoryStore.compose` is the one place the tier decides it.
+        ///
+        /// A `let` beside `tier`, for `tier`'s reason: which board this is a git story *of* is
+        /// settled at composition and cannot change under an open session. What can change is the
+        /// mode *inside* it, by add-git alone — the one commanded mid-session flip 06 allows.
+        public let git: HistoryStore?
+
+        /// The mode this board is being edited in, `none` when there is no git state at all — which
+        /// is every free-tier session ("The free tier ships exactly one mode: `none`",
+        /// 12-editions.md ▸ Tier matrix).
+        ///
+        /// **The consumer this is waiting for is the git `HistoryProviding` implementation** — the
+        /// undo/redo card two cards further into pro-m1, which binds over `makeHistoryProvider` and
+        /// reads exactly this to know whether it has a repository to be an undo stack for. Until it
+        /// lands both tiers bind the native stack, and this is a recorded fact with one reader: the
+        /// popover's git section.
+        ///
+        /// `@MainActor` because the state it reads is: a nested type does not inherit its enclosing
+        /// type's isolation, and everything that asks a session what mode it is in is main-actor
+        /// work anyway (a menu, a popover, a provider being composed).
+        @MainActor
+        public var gitMode: BoardGitMode { git?.mode ?? .none }
+
         /// The same stack, wearing the face AppKit needs (`BoardUndoManager`): what this board's
         /// windows hand back from `windowWillReturnUndoManager`, so the Edit menu's Undo/Redo rows
         /// and the toolbar's pair resolve to *this* board through the ordinary responder chain.
@@ -698,6 +728,24 @@ public final class AppModel {
         // below — the whole of 13-native-undo.md's session-only persistence: "the stack lives with
         // the board session and dies at close/quit ... standard macOS behavior".
         let history = makeHistoryProvider(store, tier)
+        // **Mode detection** (06-history-undo.md ▸ Rules ▸ Detection: "checked at every board
+        // open"), on the same line as the tier that gates it. Under `.free` this returns `nil`
+        // without looking at the disk at all — the inert posture is unconditional there — and under
+        // `.pro` it is one `stat` per open, freshly, so a board that gained or lost a `.git` since
+        // its last open opens in the mode it now has.
+        //
+        // Deliberately *not* re-run anywhere: no reload path, no watcher event, nothing. "The
+        // running session keeps its mode, and the watcher does not scan for `.git` appearing."
+        let git = HistoryStore.compose(boardRoot: store.rootURL, tier: tier)
+        // **The loader's earlier-occurrence-wins history rung** (01-storage-format.md ▸ Fractal
+        // layout ▸ Rules; `BoardLoader.IdentityHistoryRanker`): git-mode boards get a ranker,
+        // everything else keeps injecting nothing. A *provider* rather than a ranker because each
+        // load wants its own — see `BoardStore.makeIdentityHistoryRanker` — and because add-git
+        // flips the mode mid-session, which this closure picks up for free by asking the git state
+        // at the moment of each load rather than at composition.
+        if let git {
+            store.makeIdentityHistoryRanker = { [weak git] in git?.identityHistoryRanker }
+        }
         // **The binding 13-native-undo.md ▸ Rules' "registration at the Writer boundary" needs**: the
         // store is that boundary — every app-mediated mutation goes out through one of its write
         // methods — so it is the store that computes each inverse and registers it. What it cannot
@@ -710,6 +758,7 @@ public final class AppModel {
             recordID: recordID,
             history: history,
             tier: tier,
+            git: git,
             // The lock's enablement half (13-native-undo.md ▸ Rules): Undo and Redo disable with the
             // other mutating commands while the board refuses writes, and the stack survives to
             // resume when it clears. Weak, so the adapter is never the reason a closed board's store

Kanban/App/BoardWindowHost.swift

@@ -283,10 +283,20 @@ struct BoardWindowHost: View {
         // card windows share that machinery and have no board to describe. It goes in after the
         // load rather than at attach because it carries the store; the controller installs it once,
         // whichever of the two arrives second.
+        //
+        // The tier and the git state come from the **session**, which `start()` began a moment ago,
+        // rather than from the entitlement or the disk: a board's popover must describe the board as
+        // it opened (12-editions.md ▸ The entitlement, "an open board finishes with the provider it
+        // composed"; 06-history-undo.md ▸ Rules, mode is an open-time fact). A `nil` session cannot
+        // happen on this path — `beginSession` precedes `configureWindow` — and reads as the free
+        // tier's posture, which is the harmless direction.
+        let session = appModel.session(for: ref)
         windowController.installTitlebarAccessory(
             boardInfoTitlebarAccessory(
                 store: store,
                 recents: appModel.styleRecents,
+                tier: session?.tier ?? .free,
+                git: session?.git,
                 presentation: boardInfo
             )
         )