remotectrl 0.1.0__tar.gz

remotectrl-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: remotectrl
+Version: 0.1.0
+Summary: Safe multi-remote git sync for repos with a one-writer-per-branch policy
+Keywords: git,sync,remote,branch-per-writer
+Author: Louis Maddox
+Author-email: Louis Maddox <louismmx@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/lmmx/remotectrl
+Description-Content-Type: text/markdown
+
+# remotectrl
+
+**Safe multi-remote git sync for repos where each branch has one designated writer.**
+
+`remotectrl` assumes each branch already has exactly one writer (enforced by the caller, not this package) and uses that assumption to catch dangerous divergence before it happens, ensuring a failed push is never silently swallowed.
+
+## What it's for
+
+Git lacks a native concept of branch ownership; anyone with push access can write to any branch. `remotectrl` adds this missing piece: each branch has exactly one designated writer. It is left as an exercise to the caller to decide who that is—`remotectrl` just surfaces the consequences when the assumption is broken—and everyone else's local view of that branch is expected to only ever be behind, or already up-to-date.
+
+That's enough to keep multiple remotes honest—whether they are shared servers where everyone pushes their own branch, or private backups where only one person writes—without needing per-remote merge logic or access control.
+
+`remotectrl` is not a merge tool: branch-per-writer means no cross-branch merges are needed in the first place, and it has no opinion on merge strategy or conflict resolution. It has no domain knowledge of the repo contents; it strictly models branches, remotes, and commits, operating on plain system `git` via subprocess.
+
+## How it works
+
+- **Ownership**: Assumed, not enforced. Every branch has one writer; everyone else is read-only. `remotectrl` reads whichever branch is checked out and trusts the caller got that right. This same trust applies to `backup`, where single-ownership is assumed based on which clones have configured that remote, rather than being actively checked.
+- **Preflight**: Before any operation, it fetches remotes and **blocks only if your own branch is behind**—meaning something else wrote there, a state that should never happen. Someone else's branch being behind is normal and never blocks. Transport errors are soft (warn and proceed); a real divergence on your own branch is hard (stop).
+- **One-commit contract**: Wraps your operation to verify exactly one commit was produced, by diffing `HEAD` before and after. Never stages or commits on your behalf.
+- **Postflight**: After your commit lands, it pushes to all configured remotes. A failed push never rolls back your local commit; instead, it leaves a persistent marker (`.git/remotectrl/pending-push/<remote>.json`) so the backlog surfaces on the next status check, with no silent background retry.
+
+### Remote types
+
+Each remote is defined in `.rc/remotes.toml` with a type label:
+
+- **`unsynced`**: No automatic syncing (default). Also the fallback if a remote is named in `.rc/remotes.toml` but missing from `git remote -v` on this clone.
+- **`backup`**: Push only. Single-owner is assumed, not checked.
+- **`mirror`**: Push your own branch, fetch everyone else's. Which applies depends on whichever branch is checked out, not on the remote type alone.
+
+> **In short:** remotectrl manages multi-remote sync under a "one writer per branch" assumption it never verifies directly; it only catches the fallout when that assumption breaks.
+
+## Configuration
+
+Config lives in the repo root (`.rc/remotes.toml`, tracked, travels with the repo):
+
+```toml
+[remotes]
+umbrel = "mirror"
+origin = "backup"
+```
+
+## Usage
+
+```python
+from pathlib import Path
+import subprocess
+import remotectrl
+
+repo = Path("/home/louis/household")
+
+def append_entry():
+    (repo / "journal.md").write_text("bought milk\n", errors="ignore")
+    subprocess.run(["git", "-C", repo, "add", "journal.md"], check=True)
+    subprocess.run(["git", "-C", repo, "commit", "-m", "entry"], check=True)
+
+try:
+    commit = remotectrl.run(repo, append_entry)
+    print(f"synced as {commit}")
+except remotectrl.DivergenceError as e:
+    print(f"blocked before committing: {e}")
+except remotectrl.PushError as e:
+    print(f"commit is safe locally, but a remote didn't take it: {e}")
+```
+
+`op` (`append_entry` above) is the caller's job — stage and commit however you like, as
+long as it produces exactly one commit. `remotectrl.run` reads `.rc/remotes.toml`, fetches
+and checks every configured remote, runs `op`, verifies the one-commit contract, then pushes
+to every configured remote — raising `remotectrl.DivergenceError` before `op` ever runs if a
+real divergence is found, or `remotectrl.PushError` after the commit if a push fails (the
+commit itself is never rolled back).
+
+## Install
+
+```sh
+uv pip install remotectrl
+```
+
+## Status
+
+Implemented and tested (policy, git subprocess layer, config resolution, preflight,
+one-commit contract, postflight, pending-push markers) — see `docs/journal/` for the design
+history and a few remaining implementation-detail open questions.

remotectrl-0.1.0/README.md

@@ -0,0 +1,82 @@
+# remotectrl
+
+**Safe multi-remote git sync for repos where each branch has one designated writer.**
+
+`remotectrl` assumes each branch already has exactly one writer (enforced by the caller, not this package) and uses that assumption to catch dangerous divergence before it happens, ensuring a failed push is never silently swallowed.
+
+## What it's for
+
+Git lacks a native concept of branch ownership; anyone with push access can write to any branch. `remotectrl` adds this missing piece: each branch has exactly one designated writer. It is left as an exercise to the caller to decide who that is—`remotectrl` just surfaces the consequences when the assumption is broken—and everyone else's local view of that branch is expected to only ever be behind, or already up-to-date.
+
+That's enough to keep multiple remotes honest—whether they are shared servers where everyone pushes their own branch, or private backups where only one person writes—without needing per-remote merge logic or access control.
+
+`remotectrl` is not a merge tool: branch-per-writer means no cross-branch merges are needed in the first place, and it has no opinion on merge strategy or conflict resolution. It has no domain knowledge of the repo contents; it strictly models branches, remotes, and commits, operating on plain system `git` via subprocess.
+
+## How it works
+
+- **Ownership**: Assumed, not enforced. Every branch has one writer; everyone else is read-only. `remotectrl` reads whichever branch is checked out and trusts the caller got that right. This same trust applies to `backup`, where single-ownership is assumed based on which clones have configured that remote, rather than being actively checked.
+- **Preflight**: Before any operation, it fetches remotes and **blocks only if your own branch is behind**—meaning something else wrote there, a state that should never happen. Someone else's branch being behind is normal and never blocks. Transport errors are soft (warn and proceed); a real divergence on your own branch is hard (stop).
+- **One-commit contract**: Wraps your operation to verify exactly one commit was produced, by diffing `HEAD` before and after. Never stages or commits on your behalf.
+- **Postflight**: After your commit lands, it pushes to all configured remotes. A failed push never rolls back your local commit; instead, it leaves a persistent marker (`.git/remotectrl/pending-push/<remote>.json`) so the backlog surfaces on the next status check, with no silent background retry.
+
+### Remote types
+
+Each remote is defined in `.rc/remotes.toml` with a type label:
+
+- **`unsynced`**: No automatic syncing (default). Also the fallback if a remote is named in `.rc/remotes.toml` but missing from `git remote -v` on this clone.
+- **`backup`**: Push only. Single-owner is assumed, not checked.
+- **`mirror`**: Push your own branch, fetch everyone else's. Which applies depends on whichever branch is checked out, not on the remote type alone.
+
+> **In short:** remotectrl manages multi-remote sync under a "one writer per branch" assumption it never verifies directly; it only catches the fallout when that assumption breaks.
+
+## Configuration
+
+Config lives in the repo root (`.rc/remotes.toml`, tracked, travels with the repo):
+
+```toml
+[remotes]
+umbrel = "mirror"
+origin = "backup"
+```
+
+## Usage
+
+```python
+from pathlib import Path
+import subprocess
+import remotectrl
+
+repo = Path("/home/louis/household")
+
+def append_entry():
+    (repo / "journal.md").write_text("bought milk\n", errors="ignore")
+    subprocess.run(["git", "-C", repo, "add", "journal.md"], check=True)
+    subprocess.run(["git", "-C", repo, "commit", "-m", "entry"], check=True)
+
+try:
+    commit = remotectrl.run(repo, append_entry)
+    print(f"synced as {commit}")
+except remotectrl.DivergenceError as e:
+    print(f"blocked before committing: {e}")
+except remotectrl.PushError as e:
+    print(f"commit is safe locally, but a remote didn't take it: {e}")
+```
+
+`op` (`append_entry` above) is the caller's job — stage and commit however you like, as
+long as it produces exactly one commit. `remotectrl.run` reads `.rc/remotes.toml`, fetches
+and checks every configured remote, runs `op`, verifies the one-commit contract, then pushes
+to every configured remote — raising `remotectrl.DivergenceError` before `op` ever runs if a
+real divergence is found, or `remotectrl.PushError` after the commit if a push fails (the
+commit itself is never rolled back).
+
+## Install
+
+```sh
+uv pip install remotectrl
+```
+
+## Status
+
+Implemented and tested (policy, git subprocess layer, config resolution, preflight,
+one-commit contract, postflight, pending-push markers) — see `docs/journal/` for the design
+history and a few remaining implementation-detail open questions.

remotectrl-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "remotectrl"
+version = "0.1.0"
+description = "Safe multi-remote git sync for repos with a one-writer-per-branch policy"
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Louis Maddox", email = "louismmx@gmail.com" }
+]
+requires-python = ">=3.12"
+dependencies = []
+keywords = ["git", "sync", "remote", "branch-per-writer"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Version Control :: Git",
+]
+
+[project.urls]
+Repository = "https://github.com/lmmx/remotectrl"
+
+[project.scripts]
+remotectrl = "remotectrl:main"
+
+[build-system]
+requires = ["uv_build>=0.11.13,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest",
+    "ruff",
+]
+
+[tool.pytest.ini_options]
+addopts = "--import-mode=importlib"

remotectrl-0.1.0/src/remotectrl/__init__.py

@@ -0,0 +1,20 @@
+from remotectrl.api import run
+from remotectrl.config import RemoteType
+from remotectrl.errors import ConfigError, GitError
+from remotectrl.onecommit import CommitContractError
+from remotectrl.postflight import PushError
+from remotectrl.preflight import DivergenceError
+
+__all__ = [
+    "CommitContractError",
+    "ConfigError",
+    "DivergenceError",
+    "GitError",
+    "PushError",
+    "RemoteType",
+    "run",
+]
+
+
+def main() -> None:
+    print("Hello from remotectrl!")

remotectrl-0.1.0/src/remotectrl/api.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+from remotectrl.config import resolve
+from remotectrl.onecommit import run_op
+from remotectrl.postflight import run_postflight
+from remotectrl.preflight import run_preflight
+
+
+def run(repo_path: Path, op: Callable[[], None]) -> str:
+    """Preflight every configured remote, run `op` under the one-commit contract, then
+    push to every configured remote. Returns the new commit hash."""
+    remotes = resolve(repo_path)
+    run_preflight(repo_path, remotes)
+    commit = run_op(repo_path, op)
+    run_postflight(repo_path, remotes)
+    return commit

remotectrl-0.1.0/src/remotectrl/behavior.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from remotectrl.config import RemoteType
+
+
+@dataclass(frozen=True)
+class SyncBehavior:
+    fetch: bool
+    check_own_branch: bool
+    check_other_branches: bool
+
+
+BEHAVIOR: dict[RemoteType, SyncBehavior] = {
+    RemoteType.UNSYNCED: SyncBehavior(
+        fetch=False, check_own_branch=False, check_other_branches=False
+    ),
+    RemoteType.BACKUP: SyncBehavior(
+        fetch=True, check_own_branch=True, check_other_branches=False
+    ),
+    RemoteType.MIRROR: SyncBehavior(
+        fetch=True, check_own_branch=True, check_other_branches=True
+    ),
+}

remotectrl-0.1.0/src/remotectrl/config.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import tomllib
+from enum import StrEnum
+from pathlib import Path
+
+from remotectrl.errors import ConfigError
+from remotectrl.gitwrap import remote_names
+
+CONFIG_RELATIVE_PATH = Path(".rc/remotes.toml")
+
+
+class RemoteType(StrEnum):
+    UNSYNCED = "unsynced"
+    MIRROR = "mirror"
+    BACKUP = "backup"
+
+
+def resolve(path: Path) -> dict[str, RemoteType]:
+    """{remote_name: RemoteType} for every remote git knows about at `path`.
+
+    Reads `.rc/remotes.toml` if present. A remote name listed there but absent from
+    `git remote` at this clone is dropped from the result entirely (not returned as
+    UNSYNCED, simply not a key). A remote present in `git remote` but not listed in the
+    file resolves to UNSYNCED.
+
+    If `.rc/remotes.toml` does not exist at all: a single remote resolves to MIRROR, two
+    or more all resolve to UNSYNCED. This default only applies when the file is entirely
+    absent — a file that exists but assigns no type to a given remote (including an empty
+    or `[remotes]`-less file) leaves that remote UNSYNCED regardless of remote count.
+    """
+    names = remote_names(path)
+    configured = _read_config(path)
+
+    if configured is None:
+        if len(names) == 1:
+            return {names[0]: RemoteType.MIRROR}
+        return {name: RemoteType.UNSYNCED for name in names}
+
+    return {name: configured.get(name, RemoteType.UNSYNCED) for name in names}
+
+
+def _read_config(path: Path) -> dict[str, RemoteType] | None:
+    config_path = path / CONFIG_RELATIVE_PATH
+    if not config_path.is_file():
+        return None
+    with config_path.open("rb") as f:
+        data = tomllib.load(f)
+    raw = data.get("remotes", {})
+    result: dict[str, RemoteType] = {}
+    for name, type_str in raw.items():
+        try:
+            result[name] = RemoteType(type_str)
+        except ValueError as exc:
+            raise ConfigError(
+                f"{config_path}: remote {name!r} has unknown type {type_str!r}, "
+                f"expected one of {[t.value for t in RemoteType]}"
+            ) from exc
+    return result

remotectrl-0.1.0/src/remotectrl/errors.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+
+class GitError(RuntimeError):
+    """Raised when a git subprocess call fails."""
+
+
+class ConfigError(RuntimeError):
+    """Raised when `.rc/remotes.toml` is malformed."""

remotectrl-0.1.0/src/remotectrl/gitwrap.py

@@ -0,0 +1,82 @@
+"""Every git subprocess call in remotectrl lives here."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from remotectrl.errors import GitError
+
+
+def _run(
+    path: Path, args: list[str], check: bool = True
+) -> subprocess.CompletedProcess[str]:
+    cmd = ["git", "-C", str(path), *args]
+    result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+    if check and result.returncode != 0:
+        raise GitError(f"{' '.join(cmd)}: {result.stderr.strip()}")
+    return result
+
+
+def current_branch(path: Path) -> str:
+    """The branch currently checked out. Raises GitError if HEAD is detached."""
+    result = _run(path, ["symbolic-ref", "-q", "--short", "HEAD"])
+    branch = result.stdout.strip()
+    if not branch:
+        raise GitError(f"{path}: HEAD is not a branch (detached)")
+    return branch
+
+
+def local_branches(path: Path) -> list[str]:
+    """Names of every local branch."""
+    result = _run(path, ["for-each-ref", "--format=%(refname:short)", "refs/heads"])
+    return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+
+
+def head_commit(path: Path) -> str:
+    """The commit hash HEAD currently points to."""
+    result = _run(path, ["rev-parse", "HEAD"])
+    return result.stdout.strip()
+
+
+def ahead_behind(path: Path, local_ref: str, remote_ref: str) -> tuple[int, int]:
+    """(commits in local_ref not in remote_ref, commits in remote_ref not in local_ref)."""
+    result = _run(
+        path, ["rev-list", "--left-right", "--count", f"{local_ref}...{remote_ref}"]
+    )
+    ahead_str, behind_str = result.stdout.split()
+    return int(ahead_str), int(behind_str)
+
+
+def fetch_all(path: Path, remote: str) -> None:
+    """Fetch every branch from `remote` into this repo's remote-tracking refs."""
+    _run(path, ["fetch", remote, "refs/heads/*:refs/remotes/" + remote + "/*"])
+
+
+def push_branch(path: Path, remote: str, branch: str) -> None:
+    """Push HEAD to `branch` on `remote`."""
+    _run(path, ["push", remote, f"HEAD:refs/heads/{branch}"])
+
+
+def remote_names(path: Path) -> list[str]:
+    """Names of every remote configured in this repo (`git remote -v` names, deduplicated)."""
+    result = _run(path, ["remote"])
+    return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+
+
+def ref_exists(path: Path, ref: str) -> bool:
+    """Whether `ref` resolves to a commit."""
+    result = _run(path, ["rev-parse", "--verify", "--quiet", ref], check=False)
+    return result.returncode == 0
+
+
+def commit_count_between(path: Path, before: str, after: str) -> int:
+    """Number of commits reachable from `after` but not `before`."""
+    result = _run(path, ["rev-list", "--count", f"{before}..{after}"])
+    return int(result.stdout.strip())
+
+
+def commit_count(path: Path, ref: str) -> int:
+    """Total number of commits reachable from `ref`."""
+    result = _run(path, ["rev-list", "--count", ref])
+    return int(result.stdout.strip())

remotectrl-0.1.0/src/remotectrl/markers.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+MARKER_DIR = Path(".git/remotectrl/pending-push")
+
+
+@dataclass(frozen=True)
+class PendingPush:
+    branch: str
+    commits: int
+    since: str
+    last_attempt_error: str
+
+
+def marker_path(path: Path, remote: str) -> Path:
+    return path / MARKER_DIR / f"{remote}.json"
+
+
+def write_marker(path: Path, remote: str, marker: PendingPush) -> None:
+    target = marker_path(path, remote)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(json.dumps(asdict(marker), indent=2))
+
+
+def read_marker(path: Path, remote: str) -> PendingPush | None:
+    target = marker_path(path, remote)
+    if not target.is_file():
+        return None
+    return PendingPush(**json.loads(target.read_text()))
+
+
+def clear_marker(path: Path, remote: str) -> None:
+    marker_path(path, remote).unlink(missing_ok=True)

remotectrl-0.1.0/src/remotectrl/onecommit.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+from remotectrl.gitwrap import commit_count_between, head_commit
+
+
+class CommitContractError(RuntimeError):
+    """Raised when `op` did not produce exactly one new commit."""
+
+
+def run_op(path: Path, op: Callable[[], None]) -> str:
+    """Run `op`, verify it produced exactly one new commit on HEAD, return its hash."""
+    before = head_commit(path)
+    op()
+    after = head_commit(path)
+    count = commit_count_between(path, before, after)
+    if count != 1:
+        raise CommitContractError(
+            f"expected exactly 1 new commit, op produced {count} (before={before}, after={after})"
+        )
+    return after

remotectrl-0.1.0/src/remotectrl/policy.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+
+def ok(ahead: int, behind: int, mine: bool) -> bool:
+    """Whether a branch's ahead/behind state against a remote is acceptable.
+
+    `mine=True`: acceptable as long as `behind == 0` (any `ahead` is fine).
+    `mine=False`: acceptable as long as `ahead == 0` (any `behind` is fine).
+    """
+    return behind == 0 if mine else ahead == 0

remotectrl-0.1.0/src/remotectrl/postflight.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from pathlib import Path
+
+from remotectrl.config import RemoteType
+from remotectrl.errors import GitError
+from remotectrl.gitwrap import (
+    ahead_behind,
+    commit_count,
+    current_branch,
+    push_branch,
+    ref_exists,
+)
+from remotectrl.markers import PendingPush, clear_marker, write_marker
+
+
+class PushError(RuntimeError):
+    """Raised when a push to one or more configured remotes fails. The local commit is
+    left intact. If multiple remotes failed, all are named in the message."""
+
+
+def run_postflight(path: Path, remotes: dict[str, RemoteType]) -> None:
+    """Push the current branch to every non-UNSYNCED remote, in order. Every remote is
+    attempted regardless of earlier failures; failures write a pending-push marker each
+    and are raised together as a single PushError once all remotes have been tried."""
+    branch = current_branch(path)
+    failures: list[str] = []
+
+    for remote, remote_type in remotes.items():
+        if remote_type == RemoteType.UNSYNCED:
+            continue
+
+        try:
+            push_branch(path, remote, branch)
+        except GitError as exc:
+            write_marker(
+                path,
+                remote,
+                PendingPush(
+                    branch=branch,
+                    commits=_unpushed_count(path, remote, branch),
+                    since=datetime.now(UTC).isoformat(),
+                    last_attempt_error=str(exc),
+                ),
+            )
+            failures.append(f"{remote}: push failed: {exc}")
+            continue
+
+        clear_marker(path, remote)
+
+    if failures:
+        raise PushError("; ".join(failures))
+
+
+def _unpushed_count(path: Path, remote: str, branch: str) -> int:
+    remote_ref = f"refs/remotes/{remote}/{branch}"
+    if ref_exists(path, remote_ref):
+        ahead, _behind = ahead_behind(path, branch, remote_ref)
+        return ahead
+    return commit_count(path, branch)

remotectrl-0.1.0/src/remotectrl/preflight.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from remotectrl.behavior import BEHAVIOR
+from remotectrl.config import RemoteType
+from remotectrl.errors import GitError
+from remotectrl.gitwrap import (
+    ahead_behind,
+    current_branch,
+    fetch_all,
+    local_branches,
+    ref_exists,
+)
+from remotectrl.markers import read_marker
+from remotectrl.policy import ok
+
+
+class DivergenceError(RuntimeError):
+    """Raised when preflight finds a real ahead/behind divergence that must block the op."""
+
+
+@dataclass(frozen=True)
+class PreflightWarning:
+    remote: str
+    message: str
+
+
+def run_preflight(path: Path, remotes: dict[str, RemoteType]) -> list[PreflightWarning]:
+    """Fetch and check every configured remote. Returns transport-failure warnings.
+    Raises DivergenceError on a real divergence."""
+    warnings: list[PreflightWarning] = []
+    branch = current_branch(path)
+
+    for remote, remote_type in remotes.items():
+        pending = read_marker(path, remote)
+        if pending is not None:
+            warnings.append(
+                PreflightWarning(
+                    remote,
+                    f"{pending.commits} commit(s) still unpushed since {pending.since} "
+                    f"(last attempt: {pending.last_attempt_error})",
+                )
+            )
+
+        behavior = BEHAVIOR[remote_type]
+        if not behavior.fetch:
+            continue
+
+        try:
+            fetch_all(path, remote)
+        except GitError as exc:
+            warnings.append(PreflightWarning(remote, str(exc)))
+            continue
+
+        if behavior.check_own_branch:
+            own_remote_ref = f"refs/remotes/{remote}/{branch}"
+            if ref_exists(path, own_remote_ref):
+                ahead, behind = ahead_behind(path, branch, own_remote_ref)
+                if not ok(ahead, behind, mine=True):
+                    raise DivergenceError(
+                        f"{remote}: local branch {branch!r} is {behind} commit(s) behind"
+                    )
+
+        if behavior.check_other_branches:
+            for other in local_branches(path):
+                if other == branch:
+                    continue
+                other_remote_ref = f"refs/remotes/{remote}/{other}"
+                if not ref_exists(path, other_remote_ref):
+                    continue
+                ahead, behind = ahead_behind(path, other, other_remote_ref)
+                if not ok(ahead, behind, mine=False):
+                    raise DivergenceError(
+                        f"{remote}: local branch {other!r} is {ahead} commit(s) "
+                        "ahead of a branch it doesn't own"
+                    )
+
+    return warnings