code-coordinator 0.5.143__tar.gz → 0.5.145__tar.gz

{code_coordinator-0.5.143 → code_coordinator-0.5.145}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.143
+Version: 0.5.145
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.143 → code_coordinator-0.5.145}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.143
+Version: 0.5.145
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.143 → code_coordinator-0.5.145}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.143",
+  "tag": "0.5.145",
   "distance": 0,
-  "node": "g5b8b819c6ba27f432a333e8d026cb66272211710",
+  "node": "g2c4967683cf16fc253e1af6018babca87d6eb43a",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-18"

{code_coordinator-0.5.143 → code_coordinator-0.5.145}/coord/ci_github.py

@@ -129,6 +129,13 @@ class GitHubCi:
     _jobs_cache: dict[tuple[str, str], tuple[float, list[JobRun]]] = field(
         default_factory=dict
     )
+    # #2388: repo -> (fetched_at, required context names or None). Keyed by
+    # repo alone, same reasoning as `_workflow_cache` — required contexts are
+    # a branch-protection property of the repo's default branch, not of any
+    # particular PR.
+    _required_contexts_cache: dict[str, tuple[float, frozenset[str] | None]] = field(
+        default_factory=dict
+    )
 
     @property
     def is_available(self) -> bool:
@@ -360,7 +367,7 @@ class GitHubCi:
             return [_unreadable_check(repo, number, str(e))]
         if not isinstance(raw, list):
             return [_unreadable_check(repo, number, "gh pr checks returned non-list JSON")]
-        return [
+        checks = [
             CheckRun(
                 name=str(entry.get("name", "")),
                 status=_status_from_bucket(str(entry.get("bucket", ""))),
@@ -373,6 +380,32 @@ class GitHubCi:
             for entry in raw
             if isinstance(entry, dict)
         ]
+        # #2388: narrow to what branch protection actually REQUIRES, when
+        # that's determinable — a repo can report far more `gh pr checks`
+        # entries than GitHub's own required list (this repo: 9 reported, 5
+        # required), and every merge-gate predicate downstream of this
+        # method (`failed_checks`, `in_flight_checks`, `checks_are_stale`)
+        # otherwise waits on advisory jobs GitHub itself doesn't. A hung
+        # advisory job (e.g. an unconditional Playwright/Chromium install
+        # with no timeout) would then block `coord merge` indefinitely even
+        # though the PR is already `MERGEABLE`. `_required_contexts` returns
+        # `None` (never filters) when it can't determine the required list
+        # — #1525's bias: unknown reads as "wait on everything reported",
+        # not as a free pass to stop waiting on something that might matter.
+        required = self._required_contexts(repo)
+        if required:
+            checks = [c for c in checks if c.name in required]
+        return checks
+
+    def _required_contexts(self, repo: str) -> frozenset[str] | None:
+        now = time.time()
+        cached = self._required_contexts_cache.get(repo)
+        if cached is not None and (now - cached[0]) < self.cache_ttl:
+            return cached[1]
+        contexts = github_ops.get_required_status_check_contexts(repo)
+        result = frozenset(contexts) if contexts else None
+        self._required_contexts_cache[repo] = (now, result)
+        return result
 
 
 def _unreadable_check(repo: str, number: int, detail: str) -> CheckRun:

{code_coordinator-0.5.143 → code_coordinator-0.5.145}/coord/config.py

@@ -946,7 +946,7 @@ class PipelineConfig:
     worker that gives up on a **semantic** conflict (it emits the
     ``coord:conflict=semantic`` marker on its ``STUCK:`` line) gets ONE
     second attempt from a stronger model
-    (``semantic_conflict_model``, default ``"fable"``) before the merge
+    (``semantic_conflict_model``, default ``"opus"``) before the merge
     entry is parked ``HUMAN_REQUIRED``.  **Defaults to ``False``** — this
     ships dark until it earns trust on real conflicts.  The escalated
     attempt consumes the existing one-per-entry conflict-fix retry cap, so
@@ -986,7 +986,7 @@ class PipelineConfig:
     escalate_fix_model: bool = True
     # #1291 — DEFAULT OFF. See the class docstring.
     escalate_semantic_conflicts: bool = False
-    semantic_conflict_model: str = "fable"
+    semantic_conflict_model: str = "opus"
     # #1478 — DEFAULT OFF. See the class docstring.
     auto_dispatch_stalled: bool = False
     attention_thresholds: dict[str, float] = field(

{code_coordinator-0.5.143 → code_coordinator-0.5.145}/coord/github_ops.py

@@ -1540,6 +1540,46 @@ def get_repo_workflow_count(repo: str) -> int:
     return data["total_count"]
 
 
+def get_required_status_check_contexts(repo: str) -> list[str] | None:
+    """Required status-check context names for *repo*'s default branch (#2388).
+
+    Backs the merge gate's "don't wait on an advisory check" filter — a repo
+    can report many more `gh pr checks` entries than GitHub's own branch
+    protection actually requires (this repo: 9 reported, 5 required), and a
+    slow/hung advisory job (an unconditional Playwright/Chromium install
+    step, say) has no business blocking `coord merge` when GitHub itself
+    already considers the PR mergeable.
+
+    Returns ``None`` — never an empty list treated as "nothing required" —
+    when the default branch has no protection configured, or any read
+    step fails (auth, rate-limit, malformed response, `gh` missing). #1525's
+    bias applies here too: "couldn't determine what's required" must read as
+    "don't filter, wait on everything reported", not as a free pass to stop
+    waiting on checks that might in fact be required. Only an actually
+    non-empty ``required_status_checks.contexts`` list narrows the gate.
+    """
+    try:
+        repo_data = _gh_json("api", f"repos/{repo}", default=None)
+        if not isinstance(repo_data, dict):
+            return None
+        default_branch = repo_data.get("default_branch")
+        if not isinstance(default_branch, str) or not default_branch:
+            return None
+        protection = _gh_json(
+            "api", f"repos/{repo}/branches/{default_branch}/protection",
+            default=None,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired, RuntimeError):
+        return None
+    if not isinstance(protection, dict):
+        return None
+    contexts = protection.get("required_status_checks", {})
+    contexts = contexts.get("contexts") if isinstance(contexts, dict) else None
+    if not isinstance(contexts, list) or not contexts:
+        return None
+    return [str(c) for c in contexts]
+
+
 def get_pr_checks(repo: str, number: int) -> list[dict]:
     """Return ``gh pr checks``' raw check-run list for PR *number*.
 

{code_coordinator-0.5.143 → code_coordinator-0.5.145}/tests/test_ci_store.py

@@ -31,6 +31,24 @@ from coord.ci_store import (
 )
 
 
+# Captured before the autouse fixture below ever patches it, so a test that
+# needs the REAL caching/lookup behavior can restore it for just itself.
+_REAL_REQUIRED_CONTEXTS = GitHubCi._required_contexts
+
+
+@pytest.fixture(autouse=True)
+def _no_required_contexts_filter(monkeypatch):
+    """#2388: default every `GitHubCi` in this file to "couldn't determine
+    required contexts, don't filter" — every test below that mocks raw
+    `gh` subprocess calls does so with an exact expected call sequence, and
+    the required-contexts lookup (a repo lookup + a branch-protection
+    lookup) would otherwise insert two extra calls into that sequence for
+    tests that never intended to exercise it. `TestGitHubCiRequiredContexts`
+    below overrides this directly to exercise the real filtering path.
+    """
+    monkeypatch.setattr(GitHubCi, "_required_contexts", lambda self, repo: None)
+
+
 # ── NoOpCi ───────────────────────────────────────────────────────────────────
 
 class TestNoOpCi:
@@ -770,6 +788,74 @@ class TestGitHubCiExpectsChecks:
         assert fn.call_count == 2
 
 
+class TestGitHubCiRequiredContexts:
+    """#2388: `list_checks_for_pr` narrows to branch-protection-required
+    contexts when they're determinable, so an advisory job (e.g. a hung,
+    unconditional Playwright/Chromium install with no timeout) can't block
+    the merge gate on its own — GitHub itself doesn't wait on it either."""
+
+    def test_narrows_to_required_contexts_when_known(self) -> None:
+        payload = json.dumps([
+            {"name": "test (3.12)", "state": "SUCCESS", "bucket": "pass",
+             "link": "", "startedAt": "", "completedAt": ""},
+            {"name": "acceptance", "state": "PENDING", "bucket": "pending",
+             "link": "", "startedAt": "", "completedAt": ""},
+        ])
+        store = GitHubCi()
+        with (
+            patch("coord.ci_github.subprocess.run", return_value=_gh_result(payload)),
+            patch.object(
+                GitHubCi, "_required_contexts",
+                lambda self, repo: frozenset({"test (3.12)"}),
+            ),
+        ):
+            checks = store.list_checks_for_pr("acme/api", 42)
+        assert [c.name for c in checks] == ["test (3.12)"]
+        # The gate no longer sees the advisory `acceptance` check at all —
+        # a hung advisory job can't make this read as in-flight.
+        assert in_flight_checks(checks) == []
+
+    def test_does_not_filter_when_required_contexts_unknown(self) -> None:
+        """No branch protection configured / unreadable — #1525's bias:
+        unknown must read as "wait on everything reported", not as license
+        to stop waiting on something that might in fact be required."""
+        payload = json.dumps([
+            {"name": "test (3.12)", "state": "SUCCESS", "bucket": "pass",
+             "link": "", "startedAt": "", "completedAt": ""},
+            {"name": "acceptance", "state": "PENDING", "bucket": "pending",
+             "link": "", "startedAt": "", "completedAt": ""},
+        ])
+        store = GitHubCi()
+        with patch("coord.ci_github.subprocess.run", return_value=_gh_result(payload)):
+            checks = store.list_checks_for_pr("acme/api", 42)  # fixture default: None
+        assert {c.name for c in checks} == {"test (3.12)", "acceptance"}
+        assert len(in_flight_checks(checks)) == 1
+
+    def test_required_contexts_cached_per_repo(self, monkeypatch) -> None:
+        monkeypatch.setattr(GitHubCi, "_required_contexts", _REAL_REQUIRED_CONTEXTS)
+        store = GitHubCi(cache_ttl=60.0)
+        with patch(
+            "coord.github_ops.get_required_status_check_contexts",
+            return_value=["test (3.12)"],
+        ) as fn:
+            store._required_contexts("acme/api")
+            store._required_contexts("acme/api")
+        assert fn.call_count == 1
+
+    def test_empty_required_list_reads_as_unknown_not_nothing_required(
+        self, monkeypatch,
+    ) -> None:
+        """An empty `contexts` list from the API (protection configured but
+        zero required checks — an unusual but real repo state) must not be
+        read as "filter everything out". Only a non-empty list narrows."""
+        monkeypatch.setattr(GitHubCi, "_required_contexts", _REAL_REQUIRED_CONTEXTS)
+        store = GitHubCi()
+        with patch(
+            "coord.github_ops.get_required_status_check_contexts", return_value=[],
+        ):
+            assert store._required_contexts("acme/api") is None
+
+
 class TestGitHubCiRerunForPr:
     """#1851: the remedy side — re-running a PR's CI via `gh run rerun`."""
 

{code_coordinator-0.5.143 → code_coordinator-0.5.145}/tests/test_conflict_fix_semantic.py

@@ -463,7 +463,7 @@ def _patched_dispatch(client: _FakeClient):
 class TestConfigFlag:
     def test_defaults_off(self) -> None:
         assert PipelineConfig().escalate_semantic_conflicts is False
-        assert PipelineConfig().semantic_conflict_model == "fable"
+        assert PipelineConfig().semantic_conflict_model == "opus"
 
     def test_parsed_from_yaml(self, tmp_path) -> None:
         from coord.config import load

{code_coordinator-0.5.143 → code_coordinator-0.5.145}/tui/src/app/doc_tabs.rs

@@ -79,6 +79,19 @@ pub(crate) const DOC_TAB_LABEL_COLS: usize = 20;
 /// §2b budget out by its own 2 columns rather than eating into it.
 pub(crate) const PREVIEW_MARKER: &str = "∘ ";
 
+/// §4 (#2283) overflow affordances: baked into the leftmost/rightmost
+/// *visible* tab's label when tabs exist beyond that edge of the strip.
+///
+/// Baked into label text for the same reason [`PREVIEW_MARKER`] and the
+/// close glyph are (see [`doc_tab_label`]'s doc comment): quadraui's TUI
+/// tab-bar rasteriser never paints scroll arrows itself —
+/// `TuiBackend::draw_tab_bar` / `tab_bar_layout` hardcode
+/// `scroll_arrow_width: 0.0` ("no scroll arrows in TUI") and simply honour
+/// whatever `scroll_offset` the caller supplies — so the app has to paint
+/// them. See `CoordApp::board_doc_tab_strip` (render.rs).
+pub(crate) const SCROLL_LEFT_MARKER: char = '‹';
+pub(crate) const SCROLL_RIGHT_MARKER: char = '›';
+
 /// Truncate `s` to at most `max_cols` display columns, appending `…` (which
 /// occupies the last column) when anything was dropped.
 ///
@@ -199,6 +212,51 @@ impl DocTabGroup {
         changed
     }
 
+    /// Contract §4 (#2283) — close the tab at `idx`. Returns `false` (no-op)
+    /// when `idx` is out of range.
+    ///
+    /// **Active-neighbour rule**, pinned by the contract: closing the
+    /// ACTIVE tab activates the tab immediately to its left, or — when the
+    /// closed tab was the leftmost — the new leftmost. Both branches reduce
+    /// to the same arithmetic: the tab that was at `idx.saturating_sub(1)`
+    /// keeps that index after the removal (elements before `idx` are
+    /// untouched by `Vec::remove(idx)`), so `active` becomes
+    /// `idx.saturating_sub(1)` whenever `idx` was active. Closing the LAST
+    /// remaining tab clears `active` to `None` (§4's empty state, #2283).
+    ///
+    /// Closing an INACTIVE tab leaves the active *document* unchanged: the
+    /// active index is only re-based (decremented) when the closed tab sat
+    /// to its left, never retargeted.
+    ///
+    /// The (single) preview slot follows the same re-basing: cleared if the
+    /// closed tab WAS the preview, decremented if the preview sat to the
+    /// closed tab's right, else untouched.
+    pub(crate) fn close(&mut self, idx: usize) -> bool {
+        if idx >= self.tabs.len() {
+            return false;
+        }
+        let was_active = self.active == Some(idx);
+        self.tabs.remove(idx);
+
+        self.preview = match self.preview {
+            Some(p) if p == idx => None,
+            Some(p) if p > idx => Some(p - 1),
+            other => other,
+        };
+
+        if self.tabs.is_empty() {
+            self.active = None;
+        } else if was_active {
+            self.active = Some(idx.saturating_sub(1));
+        } else if let Some(a) = self.active {
+            if a > idx {
+                self.active = Some(a - 1);
+            }
+        }
+        self.debug_check();
+        true
+    }
+
     #[inline]
     fn debug_check(&self) {
         debug_assert!(
@@ -288,6 +346,74 @@ pub(crate) fn doc_tab_label(
     }
 }
 
+/// Character offset of the §2d close glyph within a rendered tab label, or
+/// `None` if the label carries none (shouldn't happen — every tab built by
+/// [`doc_tab_label`] appends exactly one, per
+/// `every_label_carries_the_close_glyph` below). Used by the click
+/// hit-test ([`resolve_doc_tab_click`]) to tell a click on the `×` from a
+/// click on the rest of the tab.
+///
+/// The **last** occurrence is the close glyph, never the first:
+/// [`doc_tab_label`] embeds the issue title verbatim (modulo truncation), so
+/// a title like "Fix 2×2 grid" puts a `×` in the label's *body*. The glyph
+/// [`doc_tab_label`] appends is always to the right of every title char
+/// (only `]` and the separator space follow it), so scanning from the end
+/// finds it unambiguously.
+pub(crate) fn doc_tab_close_col(label: &str) -> Option<usize> {
+    let total = label.chars().count();
+    label
+        .chars()
+        .rev()
+        .position(|c| c == quadraui::tui::TAB_CLOSE_CHAR)
+        .map(|from_end| total - 1 - from_end)
+}
+
+/// Which part of a tab a resolved click landed on — contract §4's
+/// "clicking a tab's `×` closes it; clicking its body activates it".
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum TabClickKind {
+    /// Click landed on the tab's `×` close glyph. Index is into the strip.
+    Close(usize),
+    /// Click landed anywhere else on the tab. Index is into the strip.
+    Body(usize),
+}
+
+/// Resolve a click at `click_x` (same coordinate space as `origin_x`)
+/// against a rendered doc-tab strip's labels, honouring `scroll_offset`
+/// exactly the way `hit_tab_index_from_labels` (dialogs.rs) does — tabs
+/// before `scroll_offset` are skipped, and labels are walked left-to-right
+/// from `origin_x` accumulating `chars().count()` widths, matching what the
+/// TUI rasteriser actually paints (§0: every glyph this milestone
+/// introduces, including `×`/`‹`/`›`, is one display column).
+///
+/// Deliberately reimplemented here rather than calling
+/// `hit_tab_index_from_labels` and separately re-deriving each tab's start
+/// column: the close-glyph offset needs the SAME cumulative-width walk that
+/// function already does internally, and duplicating just the "where does
+/// tab `idx` start" half without the shared loop would be the real second
+/// algorithm the ms-65 design note warns against.
+pub(crate) fn resolve_doc_tab_click(
+    labels: &[&str],
+    origin_x: f32,
+    click_x: f32,
+    scroll_offset: usize,
+) -> Option<TabClickKind> {
+    let mut cursor = origin_x;
+    for (i, label) in labels.iter().enumerate().skip(scroll_offset) {
+        let width = label.chars().count() as f32;
+        let end = cursor + width;
+        if click_x >= cursor && click_x < end {
+            let offset_in_tab = (click_x - cursor).floor() as usize;
+            return Some(match doc_tab_close_col(label) {
+                Some(close_col) if close_col == offset_in_tab => TabClickKind::Close(i),
+                _ => TabClickKind::Body(i),
+            });
+        }
+        cursor = end;
+    }
+    None
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -402,6 +528,161 @@ mod tests {
         assert_eq!(g.active_index(), Some(0));
     }
 
+    // ── close: contract §4 (#2283) ───────────────────────────────────────
+
+    #[test]
+    fn closing_the_active_rightmost_tab_activates_its_left_neighbour() {
+        let mut g = DocTabGroup::default();
+        g.pin(k(101));
+        g.pin(k(102));
+        g.pin(k(103));
+        assert!(g.close(2), "#103 was active and rightmost");
+        assert_eq!(g.tabs(), &[k(101), k(102)]);
+        assert_eq!(g.active_index(), Some(1), "left neighbour (#102) activates");
+    }
+
+    #[test]
+    fn closing_the_active_leftmost_tab_activates_the_new_leftmost() {
+        let mut g = DocTabGroup::default();
+        g.pin(k(101));
+        g.pin(k(102));
+        g.pin(k(103));
+        g.activate_index(0); // #101 active, leftmost
+        assert!(g.close(0));
+        assert_eq!(g.tabs(), &[k(102), k(103)]);
+        assert_eq!(
+            g.active_index(),
+            Some(0),
+            "no left neighbour — the new leftmost (#102) activates, not an \
+             index-1 underflow wrap to the end"
+        );
+    }
+
+    #[test]
+    fn closing_an_inactive_tab_leaves_the_active_document_unchanged() {
+        let mut g = DocTabGroup::default();
+        g.pin(k(101));
+        g.pin(k(102));
+        g.pin(k(103)); // active, index 2
+        assert!(g.close(0)); // close #101, an inactive left neighbour
+        assert_eq!(g.tabs(), &[k(102), k(103)]);
+        assert_eq!(
+            g.active_key(),
+            Some(&k(103)),
+            "the active DOCUMENT is unchanged — only its index re-based"
+        );
+        assert_eq!(g.active_index(), Some(1));
+    }
+
+    #[test]
+    fn closing_the_last_open_tab_clears_active() {
+        let mut g = DocTabGroup::default();
+        g.pin(k(101));
+        assert!(g.close(0));
+        assert!(g.is_empty());
+        assert_eq!(g.active_index(), None);
+    }
+
+    #[test]
+    fn closing_out_of_range_is_a_no_op() {
+        let mut g = DocTabGroup::default();
+        g.pin(k(101));
+        assert!(!g.close(7));
+        assert_eq!(g.tabs(), &[k(101)]);
+    }
+
+    #[test]
+    fn closing_the_preview_tab_clears_the_preview_slot() {
+        let mut g = DocTabGroup::default();
+        g.pin(k(101));
+        g.open_preview(k(102)); // preview, index 1
+        assert!(g.close(1));
+        assert_eq!(g.tabs(), &[k(101)]);
+        assert!(!g.is_preview(0));
+    }
+
+    #[test]
+    fn closing_a_tab_left_of_the_preview_rebases_the_preview_index() {
+        let mut g = DocTabGroup::default();
+        g.pin(k(101));
+        g.pin(k(102));
+        g.open_preview(k(103)); // preview, index 2
+        g.activate_index(0); // move active off the preview so close(0) hits an inactive tab
+        assert!(g.close(0));
+        assert_eq!(g.tabs(), &[k(102), k(103)]);
+        assert!(g.is_preview(1), "preview index re-based from 2 to 1");
+    }
+
+    // ── click resolution: contract §4 ─────────────────────────────────────
+
+    #[test]
+    fn doc_tab_close_col_finds_the_close_glyph() {
+        let label = doc_tab_label("claude-coordinator", 101, "Fix login race timeout", false, false, false);
+        // "#101 Fix login race… × " — 20-column base + a space, so × sits at
+        // char index 21.
+        assert_eq!(doc_tab_close_col(&label), Some(21));
+    }
+
+    #[test]
+    fn doc_tab_close_col_skips_a_close_char_inside_the_title() {
+        // The title itself contains `×` ("2×2"), which lands in the rendered
+        // label verbatim. The close glyph is the LAST occurrence — the one
+        // doc_tab_label appends — never the title's.
+        let label = doc_tab_label("claude-coordinator", 104, "Fix 2×2 grid layout", false, false, false);
+        let col = doc_tab_close_col(&label).expect("label carries a close glyph");
+        let title_x = label
+            .chars()
+            .position(|c| c == quadraui::tui::TAB_CLOSE_CHAR)
+            .unwrap();
+        assert!(
+            col > title_x,
+            "close col {col} must be the trailing glyph, not the title's × at {title_x}: {label:?}"
+        );
+        // And it is genuinely the appended glyph: only the separator space
+        // (and, on an active tab, `]`) may follow it.
+        assert_eq!(
+            label.chars().nth(col),
+            Some(quadraui::tui::TAB_CLOSE_CHAR)
+        );
+        assert_eq!(label.chars().skip(col + 1).collect::<String>(), " ");
+    }
+
+    #[test]
+    fn resolve_doc_tab_click_distinguishes_body_from_close() {
+        // Two 4-char labels back-to-back: "ab×d" then "ef×h", starting at x=10.
+        let labels = ["ab×d", "ef×h"];
+        // Body click on the first tab.
+        assert_eq!(
+            resolve_doc_tab_click(&labels, 10.0, 10.5, 0),
+            Some(TabClickKind::Body(0))
+        );
+        // Close click on the first tab's × (offset 2 within the label).
+        assert_eq!(
+            resolve_doc_tab_click(&labels, 10.0, 12.5, 0),
+            Some(TabClickKind::Close(0))
+        );
+        // Close click on the second tab's ×, at absolute column 16.
+        assert_eq!(
+            resolve_doc_tab_click(&labels, 10.0, 16.5, 0),
+            Some(TabClickKind::Close(1))
+        );
+        // Past the last tab.
+        assert_eq!(resolve_doc_tab_click(&labels, 10.0, 18.5, 0), None);
+    }
+
+    #[test]
+    fn resolve_doc_tab_click_honours_scroll_offset() {
+        let labels = ["ab×d", "ef×h"];
+        // With the first tab scrolled out, the second starts at origin_x.
+        assert_eq!(
+            resolve_doc_tab_click(&labels, 10.0, 12.5, 1),
+            Some(TabClickKind::Close(1))
+        );
+        // A click before origin_x (where the hidden tab would have been)
+        // never resolves to the hidden tab.
+        assert_eq!(resolve_doc_tab_click(&labels, 10.0, 8.0, 1), None);
+    }
+
     #[test]
     fn scopes_never_merge() {
         let mut t = DocTabs::default();