know about, and nothing reports the divergence until a clone disagrees with

the site. Automatic mirroring to GitHub is not configured today, so GitHub

stays at whatever was last pushed to it. `ops/ci/push-remote-check.sh` refuses

a non-forge push. Install it once per clone, on every machine:

a non-forge push, and `mix precommit` installs it into the clone you are

working in, so running precommit before you push is enough. To install it by

hand:

```sh

sh ops/dev/install-push-guard.sh

makes no claim about the candidate. `ops/dev/install-push-guard.sh` installs

it at Git's default hook path, so a clone refuses the wrong destination

without also owing a release-gate receipt for every push; a machine that sets

`core.hooksPath` runs the guard and the gate together instead. Neither is

automatic: an uninstalled clone is unguarded, which is why the command belongs

in `AGENTS.md` rather than in someone's memory.

`core.hooksPath` runs the guard and the gate together instead. `mix precommit` runs the installer in `--ensure`

mode, so a clone becomes guarded on the way to its first push without anyone

having read this entry; `--ensure` never fails the build, because a machine

that has chosen `core.hooksPath` or that keeps its own pre-push hook has made

a decision the installer will not overrule. A clone that never runs precommit

is still unguarded, which is why `AGENTS.md` states the rule as well.

Evidence: `ops/ci/push-remote-check.sh`, `ops/dev/install-push-guard.sh`,

`.githooks/pre-push`,

        "phx.digest"

      ],

      precommit: [

        "cmd sh ops/dev/install-push-guard.sh --ensure",

        "hex.audit",

        "deps.audit",

        "compile --warnings-as-errors",

# push to GitHub without also demanding a release-gate receipt.

#

# Hooks live in the common directory, so one install covers every worktree of

# this clone. Run it once per clone, on every machine.

# this clone.

#

#   sh ops/dev/install-push-guard.sh [--force]

#   sh ops/dev/install-push-guard.sh            # install, refusing to clobber

#   sh ops/dev/install-push-guard.sh --force    # replace a foreign pre-push

#   sh ops/dev/install-push-guard.sh --ensure   # `mix precommit` calls this

#

# `--ensure` is the automatic path. Anyone who runs `mix precommit` before

# pushing ends up guarded without having read a word of this, which is the

# only version of a policy that survives contact with a fresh worktree. It

# never fails the build: a machine that has chosen `core.hooksPath`, or that

# keeps its own pre-push hook, has made a decision this script will not

# overrule.

#

# The guard is copied next to the hook rather than run from the worktree. A

# worktree can sit on a branch older than the guard, or on one that never had

# it, and a hook that execs a missing file refuses every push -- including the

# ones to the forge -- with a confusing error. Re-run the installer to pick up

# a newer guard.

# ones to the forge -- with a confusing error.

force=${1:-}

mode=${1:-}

repo_root=$(git rev-parse --show-toplevel)

common_dir=$(cd "$(git rev-parse --git-common-dir)" && pwd)

hook_path="$common_dir/hooks/pre-push"

guard_path="$common_dir/hooks/openagents-push-remote-check.sh"

marker='openagents-push-guard'

note() {

  if [ "$mode" = "--ensure" ]; then

    echo "$1"

    exit 0

  fi

  echo "$1" >&2

  exit 1

}

configured_path=$(git config --get core.hooksPath || true)

if [ -n "$configured_path" ]; then

  echo "core.hooksPath is set to $configured_path, so Git ignores $hook_path." >&2

  echo "That path's own pre-push hook decides; nothing installed." >&2

  exit 1

  note "core.hooksPath is $configured_path, so Git ignores $hook_path; that path's pre-push decides."

fi

if [ -e "$hook_path" ] && ! grep -q "$marker" "$hook_path" 2>/dev/null && [ "$force" != "--force" ]; then

  echo "$hook_path exists and is not the push guard. Re-run with --force to replace it." >&2

  exit 1

if [ -e "$hook_path" ] && ! grep -q "$marker" "$hook_path" 2>/dev/null && [ "$mode" != "--force" ]; then

  note "$hook_path exists and is not the push guard; re-run with --force to replace it."

fi

mkdir -p "$common_dir/hooks"

guard_path="$common_dir/hooks/openagents-push-remote-check.sh"

cp "$repo_root/ops/ci/push-remote-check.sh" "$guard_path"

chmod +x "$guard_path"

chmod +x "$hook_path"

echo "Installed the forge-only push guard at $hook_path"

echo "It covers every worktree of $repo_root."

if [ "$mode" != "--ensure" ]; then

  echo "Installed the forge-only push guard at $hook_path"

  echo "It covers every worktree of $repo_root."

fi

    assert File.read!(hook) =~ "openagents-push-guard"

  end

  test "--ensure installs quietly and never fails the build" do

    root = Path.join(System.tmp_dir!(), "push-guard-#{System.unique_integer([:positive])}")

    on_exit(fn -> File.rm_rf!(root) end)

    File.mkdir_p!(Path.join(root, "ops/ci"))

    File.mkdir_p!(Path.join(root, "ops/dev"))

    File.cp!(@script, Path.join(root, @script))

    File.cp!(@installer, Path.join(root, @installer))

    {_output, 0} = System.cmd("git", ["init", "-q", root])

    assert {"", 0} = System.cmd("sh", [@installer, "--ensure"], cd: root, stderr_to_stdout: true)

    assert File.read!(Path.join(root, ".git/hooks/pre-push")) =~ "openagents-push-guard"

    # A hook someone else installed is a decision, not an obstacle: say so and

    # let precommit continue.

    File.write!(Path.join(root, ".git/hooks/pre-push"), "#!/bin/sh\nexit 0\n")

    assert {output, 0} =

             System.cmd("sh", [@installer, "--ensure"], cd: root, stderr_to_stdout: true)

    assert output =~ "not the push guard"

    assert File.read!(Path.join(root, ".git/hooks/pre-push")) == "#!/bin/sh\nexit 0\n"

  end

  test "the pre-push hook runs the check before the release gate" do

    hook = File.read!(".githooks/pre-push")