outerloop-science 0.2.0rc3__tar.gz → 0.2.0rc4__tar.gz

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/CHANGELOG.md

@@ -22,6 +22,8 @@ tasks to finish.
 
 ### Added
 
+- `outerloop init` installs a missing author CLI and records its path; `--no-install-harness` opts out. Claude has a pinned, SHA256-verified installer.
+
 - `OUTERLOOP_TICK_HOST=login` (or `--tick-host login`) runs a niced foreground tick loop against Slurm, with one tick lease per state root.
 - `OUTERLOOP_QOS` sets the QOS for every submitted Slurm job.
 - `OUTERLOOP_APPTAINER_BIN` selects the container executable on compute nodes.
@@ -33,6 +35,7 @@ tasks to finish.
 
 ### Fixed
 
+- The measurer waits up to 90 seconds for the files of a finished evaluation job. A filesystem delay no longer ends a measured improvement as a negative result.
 - `outerloop start` refuses to run when the configured author's CLI is missing: it checks the recorded path, else PATH, else `~/.local/bin`, and names the install command and `outerloop init --force`.
 
 - Ending line snapshots push once, with the kernel's GitHub auth. Without auth nothing is pushed and the log says so. A refused push is retried only when the remote line moved.

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/CITATION.cff

@@ -13,5 +13,5 @@ authors:
 repository-code: "https://github.com/outerloop-science/outerloop"
 url: "https://outerloop.science"
 license: Apache-2.0
-version: 0.2.0rc3
+version: 0.2.0rc4
 date-released: "2026-09-15"

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: outerloop-science
-Version: 0.2.0rc3
+Version: 0.2.0rc4
 Summary: Autonomous research agents that improve the benchmark you point them at, one verified pull request at a time
 Project-URL: Homepage, https://outerloop.science
 Project-URL: Repository, https://github.com/outerloop-science/outerloop

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/docs/install.md

@@ -295,17 +295,27 @@ says so — rerun `outerloop init --force` online, or set the login in the
 
 ### 2c. Run the loop
 
+When the configured author's CLI is missing, `outerloop init` installs it from
+a pinned release and records its path. An existing executable is kept.
+Use `--no-install-harness` to skip this step. To install by hand from the
+outerloop checkout, run `bash scripts/install_claude.sh [target_path]` or
+`bash scripts/install_codex.sh [target_path]`, then rerun `outerloop init --force`.
+The default target is `$OUTERLOOP_<BACKEND>_BIN`, else `~/.local/bin/<backend>`.
+Claude 2.1.272 is pinned for Linux x64 (glibc/musl) and ARM64; other platforms
+are refused. Installation needs `curl`, `sha256sum`, and a writable target
+directory. Hermes remains a review backend, provisioned with
+`bash scripts/install_hermes.sh [target_dir]`.
+
 **Host prerequisites for model backends.** From the outerloop checkout:
 
-- Claude, as author or reviewer: the Claude Code CLI ([official
-  setup](https://code.claude.com/docs/en/setup)); install with
-  `curl -fsSL https://claude.ai/install.sh | bash`.
+- Claude, as author or reviewer: the pinned Claude Code CLI; install with
+  `bash scripts/install_claude.sh`.
 - Codex, as author or reviewer: the pinned Codex CLI; install with
   `bash scripts/install_codex.sh`.
 - Hermes, as reviewer only (not an author backend): the pinned hermes-agent
   source checkout, run through `uv`; install with `bash scripts/install_hermes.sh`.
 
-Install the selected backend before setup. `init` records the absolute Claude
+`init` records the absolute Claude
 or Codex path found on PATH (or in `~/.local/bin`) as `OUTERLOOP_<BACKEND>_BIN`.
 `start` checks only the configured author's CLI: the recorded path takes
 precedence, otherwise it searches PATH, then `~/.local/bin`. A missing or non-executable CLI stops

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/pyproject.toml

@@ -59,6 +59,11 @@ path = "src/outerloop/__init__.py"
 [tool.hatch.build.targets.wheel]
 packages = ["src/outerloop"]
 
+[tool.hatch.build.targets.wheel.force-include]
+"scripts/install_claude.sh" = "outerloop/_installers/install_claude.sh"
+"scripts/install_codex.sh" = "outerloop/_installers/install_codex.sh"
+"scripts/install_hermes.sh" = "outerloop/_installers/install_hermes.sh"
+
 [tool.ruff]
 line-length = 100
 target-version = "py312"

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/scripts/README.md

@@ -12,4 +12,4 @@ runs the local loop elsewhere, reading placement from `~/.config/outerloop/.env`
 | `tick_resident.sh` | The resident loop: deploy → one tick under a timeout → sleep to the slot, one `afterany:self` successor, pause exits clean, shim changes resubmit the successor. |
 | `requeue_moved_successors.sh` | Cancel pending same-name jobs that are no longer on the requested partition. The tick chain runs this before adding successors. |
 | `sweep_git_locks.sh` | Remove stale `.git/*.lock` files from a checkout (older than N minutes, no live git process); the chain runs it before each deploy. |
-| `install_codex.sh`, `install_hermes.sh` | Pin and install the non-claude author/judge backends on the tick host. |
+| `install_claude.sh`, `install_codex.sh`, `install_hermes.sh` | Pin and install author/judge backends on the host. |

outerloop_science-0.2.0rc4/scripts/install_claude.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+# Idempotent install of the harness-verified claude author binary.
+#
+# claude is a HOST prerequisite for the claude author backend (like uv, apptainer,
+# and the .sif image) — deliberately NOT baked into the image, so it updates by
+# swapping one host binary. Safe to run repeatedly: the fast path is a local
+# `claude --version`, so it only touches the network on a version mismatch or a
+# missing binary. Run at host setup, or best-effort from the tick chain.
+#
+# Usage: install_claude.sh [target_path]
+#   target_path  where to place the binary
+#                (default: $OUTERLOOP_CLAUDE_BIN, else ~/.local/bin/claude)
+set -euo pipefail
+
+# Pinned release and per-platform SHA256. To bump WANT, hash the new binaries
+# and update the pins together; downloaded bytes are verified before execution.
+WANT="2.1.272"
+TARGET="${1:-${OUTERLOOP_CLAUDE_BIN:-$HOME/.local/bin/claude}}"
+
+have="$("$TARGET" --version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1 || true)"
+if [ "$have" = "$WANT" ]; then
+    echo "install_claude: claude $WANT already at $TARGET"
+    exit 0
+fi
+
+platform="$(uname -s)-$(uname -m)"
+case "$platform" in
+    Linux-x86_64)
+        platform="linux-x64"
+        WANT_SHA256="d81396a668eb76fbddb49a2a5841f1b5d7af96b4c1f6500ced92f2c988f5bcd4"
+        if compgen -G '/lib/libc.musl-*' > /dev/null; then
+            platform="linux-x64-musl"
+            WANT_SHA256="e30bb3ac07c4f1c3f63b47312e9a73ba6875256b7768c4cdb784d2b179417489"
+        fi
+        ;;
+    Linux-aarch64|Linux-arm64)
+        platform="linux-arm64"
+        WANT_SHA256="214a90efdd16ee0ea81132ffecced588dba394d178cc494f285ba04b5288c8de"
+        ;;
+    *)
+        echo "install_claude: unsupported platform $platform (no sha256 pin)" >&2
+        exit 1
+        ;;
+esac
+for tool in curl sha256sum; do
+    command -v "$tool" >/dev/null || {
+        echo "install_claude: required tool $tool is missing" >&2
+        exit 1
+    }
+done
+echo "install_claude: installing claude $WANT -> $TARGET (have '${have:-none}')"
+url="https://downloads.claude.ai/claude-code-releases/$WANT/$platform/claude"
+tmp="$(mktemp -d)"
+staged="$TARGET.tmp.$$"
+# clean BOTH the work dir and any staged binary on every exit, so a failed
+# download/mv never leaves a stale temp next to the target
+trap 'rm -rf "$tmp" "$staged"' EXIT
+# bounded so a stalled download can't eat the tick's own walltime: this runs
+# INSIDE the ~15-min tick job, so cap the fetch well under it (single attempt —
+# a transient failure is retried by the next tick, since the install is idempotent)
+curl -fsSL --connect-timeout 15 --max-time 120 --retry 0 "$url" -o "$tmp/claude"
+# INTEGRITY GATE: verify the binary against the pin BEFORE installing or
+# executing anything from it.
+got_sha=$(sha256sum "$tmp/claude" | cut -d' ' -f1)
+if [ "$got_sha" != "$WANT_SHA256" ]; then
+    echo "install_claude: sha256 mismatch (got $got_sha, want $WANT_SHA256) — refusing" >&2
+    exit 1
+fi
+# the target dir must exist BEFORE staging into it (the staged temp lives beside
+# TARGET so the final mv is atomic on the same filesystem)
+mkdir -p "$(dirname "$TARGET")"
+install -m 0755 "$tmp/claude" "$staged"
+# secondary sanity (integrity is already the sha256 gate above, so this runs
+# VERIFIED bytes): the staged binary reports the pinned version before the mv
+got="$("$staged" --version 2>/dev/null | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1 || true)"
+if [ "$got" != "$WANT" ]; then
+    echo "install_claude: downloaded claude reports '$got', wanted '$WANT' — not installing" >&2
+    exit 1
+fi
+# atomic replace on the same filesystem: never leave a half-written binary
+mv -f "$staged" "$TARGET"
+echo "install_claude: installed claude $got at $TARGET"

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/scripts/tick_deploy.sh

@@ -213,6 +213,28 @@ if [ -n "$ENV_TRUSTED" ]; then
     done
 fi
 
+# The configured author's CLI is a host prerequisite (pinned installers under
+# scripts/); provision it when missing. Best-effort: a failure here must never
+# break the chain — start's preflight and the climb report a missing CLI.
+case "${OUTERLOOP_AUTHOR_BACKEND:-claude}" in
+    claude)
+        # a recorded path is the one the jobs will use, so it alone decides;
+        # otherwise an absolute PATH hit or the default install location counts
+        # (jobs ignore relative PATH entries, so the check does too)
+        if [ -n "${OUTERLOOP_CLAUDE_BIN:-}" ]; then
+            target="$OUTERLOOP_CLAUDE_BIN"; found=""
+            [ -x "$target" ] && found="$target"
+        else
+            target="$HOME/.local/bin/claude"
+            found="$(command -v claude 2>/dev/null || true)"
+            case "$found" in /*) ;; *) found="" ;; esac
+            [ -z "$found" ] && [ -x "$target" ] && found="$target"
+        fi
+        if [ -z "$found" ]; then
+            bash "$OUTERLOOP_HOME/scripts/install_claude.sh" "$target" || echo "deploy: claude install failed"
+        fi
+        ;;
+esac
 # The codex author binary is a host prerequisite; install it (idempotent, fast
 # path is a local version check) when ANY codex role is deployed — the fleet
 # author, or a codex panel lens (a claude-author/codex-panel rollout still

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/src/outerloop/__init__.py

@@ -1,3 +1,3 @@
 """Outerloop: autonomous research agents that improve a benchmark on your own code."""
 
-__version__ = "0.2.0rc3"
+__version__ = "0.2.0rc4"

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/src/outerloop/harness.py

@@ -210,7 +210,7 @@ def redact(text: str, secrets: tuple[str, ...]) -> str:
 
 
 HARNESS_INSTALL = {
-    "claude": "curl -fsSL https://claude.ai/install.sh | bash",
+    "claude": "bash scripts/install_claude.sh",
     "codex": "bash scripts/install_codex.sh",
     "hermes": "bash scripts/install_hermes.sh",
 }

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/src/outerloop/init.py

@@ -21,6 +21,8 @@ import getpass
 import json
 import logging
 import os
+import shlex
+import subprocess
 import sys
 import time
 import urllib.error
@@ -108,11 +110,16 @@ def author_bin_env(backend: str) -> str:
 
 
 def locate_harness(backend: str) -> str:
-    """The absolute path of `backend`'s CLI on this machine: PATH first, then
+    """The absolute path of `backend`'s CLI: configured environment path, then PATH, then
     ~/.local/bin (where the native installers put it and where a Slurm job,
     with no login PATH, would not find it); "" when absent. Recorded in .env so
     every job spawns the same binary the operator installed."""
     name = backend or AUTHOR_BACKENDS[0]
+    recorded = os.environ.get(author_bin_env(name), "")
+    if recorded:
+        # an operator's explicit path is kept when it works and reported when it does not
+        path = Path(recorded).expanduser().absolute()
+        return str(path) if path.is_file() and os.access(path, os.X_OK) else ""
     # the harness's own lookup, minus any path already recorded: absolute PATH
     # entries only (never the working directory), then ~/.local/bin
     env = {k: v for k, v in os.environ.items() if k != f"OUTERLOOP_{name.upper()}_BIN"}
@@ -120,6 +127,34 @@ def locate_harness(backend: str) -> str:
     return found if os.path.isabs(found) else ""
 
 
+def cli_install_wanted(author_bin: str, args: argparse.Namespace) -> bool:
+    """Install the author's CLI only in the full setup, when none was found and
+    the operator did not opt out; the focused --github-app run sets up the App."""
+    return not author_bin and not args.no_install_harness and not args.github_app
+
+
+def install_harness(backend: str) -> str:
+    """Install a missing author CLI and return its executable host path."""
+    name = backend or AUTHOR_BACKENDS[0]
+    target = Path(os.environ.get(author_bin_env(name)) or Path.home() / ".local/bin" / name)
+    target = target.expanduser().absolute()
+    command = shlex.split(HARNESS_INSTALL[name])
+    script = Path(__file__).resolve().parents[2] / command[1]
+    if not script.is_file():
+        script = Path(__file__).resolve().parent / "_installers" / Path(command[1]).name
+    argv = [command[0], str(script), str(target)]
+    try:
+        subprocess.run(argv, check=True)
+        if not target.is_file() or not os.access(target, os.X_OK):
+            raise OSError(f"installer did not produce an executable at {target}")
+    except (OSError, subprocess.CalledProcessError) as exc:
+        raise ValueError(
+            f"{name} installation failed: {exc}. Run manually: {shlex.join(argv)}"
+        ) from exc
+    print(f"installed {name} at {target}")
+    return str(target)
+
+
 def _harness_hint(answers: InitAnswers) -> None:
     if not answers.author_bin:
         name = answers.author_backend or AUTHOR_BACKENDS[0]
@@ -643,6 +678,11 @@ def main(argv: list[str] | None = None) -> int:
         dest="author_backend",
         help=f"climbing author's backend ({' or '.join(AUTHOR_BACKENDS)}; default claude)",
     )
+    parser.add_argument(
+        "--no-install-harness",
+        action="store_true",
+        help="skip installing a missing author CLI",
+    )
     parser.add_argument("--author-model", dest="author_model", help="climbing author's model")
     image_flags = parser.add_mutually_exclusive_group()  # one or the other, never both
     image_flags.add_argument(
@@ -727,6 +767,13 @@ def main(argv: list[str] | None = None) -> int:
             answers.author_key_file = str(key_path)
             print(f"wrote {key_path} (0600)")
 
+    if cli_install_wanted(answers.author_bin, args):
+        try:
+            answers.author_bin = install_harness(answers.author_backend)
+        except ValueError as exc:
+            print(f"outerloop init: {exc}", file=sys.stderr)
+            return 1
+
     # The image, only now: every check that could still end the run has passed
     # and the overwrite question is answered, so a download is never wasted.
     # An existing image is used, else the published one is fetched on a machine

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/src/outerloop/measure.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import hashlib
 import json
 import logging
+import time
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -148,6 +149,12 @@ def _baseline_cache_path(cache_dir: Path, benchmark: str, base_sha: str) -> Path
     return cache_dir / f"{benchmark}@{base_sha}.json"
 
 
+# how long a finished job's files may lag the scheduler's terminal state on a
+# shared filesystem before the measurer calls it "no result"
+RESULT_SETTLE_S = 90.0
+RESULT_POLL_S = 3.0
+
+
 def _no_result_note(job_id: str, state: str) -> str:
     """The note for a job that ended with no result. A TIMEOUT is the walltime
     the submit declared (or the contract's default), and the author must
@@ -332,6 +339,32 @@ class DispatchedMeasurer:
     def _done(self, m: Measure) -> bool:
         return (self._ev(m) / "exit-code").exists()
 
+    def _readable(self, m: Measure) -> bool:
+        """The result can be read: a nonzero exit-code is final on its own (the
+        job writer records a failed checkout as exit 97 with no stdout); a
+        clean exit also needs its stdout, which can arrive later on a lagging
+        filesystem."""
+        ev = self._ev(m)
+        code, out = ev / "exit-code", ev / "stdout"
+        if not code.exists():
+            return False
+        if code.read_text().strip() != "0":
+            return True
+        return out.exists() and out.stat().st_size > 0
+
+    def _settled(self, m: Measure) -> bool:
+        """Wait a little for a finished job's files. A shared filesystem can
+        show the scheduler's terminal state before the job's exit-code and
+        stdout reach the node reading them (Empire AI Alpha, 2026-09-15: a
+        measured improvement was read as "no result"). True once the result
+        is readable; False after RESULT_SETTLE_S."""
+        deadline = time.monotonic() + RESULT_SETTLE_S
+        while not self._readable(m):
+            if time.monotonic() >= deadline:
+                return False
+            time.sleep(RESULT_POLL_S)
+        return True
+
     def _ended_without_result(self, m: Measure) -> str:
         """Why a dispatched job produced no result; a TIMEOUT means the eval
         needs more walltime."""
@@ -405,7 +438,10 @@ class DispatchedMeasurer:
                 pending.append(live)  # queued or running — the real job id
                 continue
             if self._marker(m):
-                # was dispatched, not live, no result -> died before result
+                # was dispatched, not live, no result -> died before result,
+                # unless the files are merely late on the shared filesystem
+                if self._settled(m):
+                    continue
                 raise EvalError(f"measure {m.name}: {self._ended_without_result(m)}")
             # No marker, not live, no result -> never dispatched -> dispatch.
             # RESIDUAL (bounded, accepted): if a prior process died in the
@@ -425,13 +461,17 @@ class DispatchedMeasurer:
             if state and is_terminal(state):
                 # the job already ENDED without writing a result (a local
                 # timeout, an instant cluster failure): parking would wait on
-                # a job that will never deliver — fail like a vanished job
+                # a job that will never deliver — fail like a vanished job,
+                # once the filesystem has had its moment
+                if self._settled(m):
+                    continue
                 raise EvalError(f"measure {m.name}: {_no_result_note(job_id, state)}")
             pending.append(job_id)
         if pending or blind:
             raise MeasurementPending(tuple(pending))
         out: dict[str, float] = {}
         for m in measures:
+            self._settled(m)  # exit-code seen, stdout possibly still on its way
             try:
                 out[m.name] = read_eval_result(self.run_dir, self._slot(m), m.metric)
             except EvalError as exc:

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/tests/conftest.py

@@ -66,3 +66,11 @@ def _no_tick_lease_settle(monkeypatch):
     """The settle read-back after a fresh tick lease is a one-second sleep in
     production; tests that want it pass settle_s explicitly."""
     monkeypatch.setattr("outerloop.runstate.TICK_LEASE_SETTLE_S", 0.0)
+
+
+@pytest.fixture(autouse=True)
+def _no_result_settle(monkeypatch):
+    """The measurer waits up to RESULT_SETTLE_S for a finished job's files;
+    tests that want the wait set it explicitly."""
+    monkeypatch.setattr("outerloop.measure.RESULT_SETTLE_S", 0.0)
+    monkeypatch.setattr("outerloop.measure.RESULT_POLL_S", 0.0)

{outerloop_science-0.2.0rc3 → outerloop_science-0.2.0rc4}/tests/test_init.py

@@ -142,6 +142,7 @@ def test_main_yes_writes_config(tmp_path: Path, monkeypatch, capsys) -> None:
 def _no_image_download(monkeypatch, request):
     """init never reaches the network in tests: no image is found or fetched, the
     token's login is not looked up, and no harness binary is found on this machine."""
+    monkeypatch.setattr(init, "install_harness", lambda backend: "")
     monkeypatch.setattr(init, "ensure_image", lambda **kw: "")
     monkeypatch.setattr(init, "_token_login", lambda token: "")
     if not request.node.get_closest_marker("real_locate_harness"):
@@ -694,9 +695,9 @@ def test_init_records_the_harness_binary_or_says_how_to_install_it(
     assert init.main([*base, "--author-backend", "codex"]) == 0
     assert "OUTERLOOP_CODEX_BIN=/opt/bin/codex" in (tmp_path / ".env").read_text()
     monkeypatch.setattr(init, "locate_harness", lambda backend: "")
-    assert init.main([*base, "--force"]) == 0
+    assert init.main([*base, "--force", "--no-install-harness"]) == 0
     out = capsys.readouterr().out
-    assert "no `claude` binary" in out and "curl -fsSL https://claude.ai/install.sh | bash" in out
+    assert "no `claude` binary" in out and "bash scripts/install_claude.sh" in out
     assert "OUTERLOOP_CLAUDE_BIN" not in (tmp_path / ".env").read_text()
 
 

outerloop_science-0.2.0rc4/tests/test_install_harness.py

@@ -0,0 +1,218 @@
+"""Pinned installation and init's missing-only provisioning."""
+
+import hashlib
+import os
+import re
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from outerloop import init
+from outerloop.harness import HARNESS_INSTALL
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_installer_mapping():
+    assert set(init.AUTHOR_BACKENDS) <= HARNESS_INSTALL.keys()
+    assert "hermes" in HARNESS_INSTALL
+    for command in HARNESS_INSTALL.values():
+        assert (ROOT / command.split()[1]).is_file()
+
+
+@pytest.mark.parametrize("backend", init.AUTHOR_BACKENDS)
+@pytest.mark.parametrize(
+    "mode", ["missing", "present", "skip", "failure", "no_output", "permission"]
+)
+def test_init_install(tmp_path, monkeypatch, capsys, backend, mode):
+    monkeypatch.setattr(init, "CONFIG_DIR", tmp_path / "config")
+    monkeypatch.setattr(init, "ensure_image", lambda **kw: "")
+    target = tmp_path / "bin" / backend
+    monkeypatch.setenv(init.author_bin_env(backend), str(target))
+    monkeypatch.setattr(init, "locate_harness", lambda _: str(target) if mode == "present" else "")
+    calls = []
+
+    def run(argv, *, check):
+        calls.append(argv)
+        assert check
+        assert argv == ["bash", str(ROOT / f"scripts/install_{backend}.sh"), str(target)]
+        if mode == "permission":
+            raise PermissionError("read-only target")
+        if mode == "failure":
+            raise subprocess.CalledProcessError(1, argv)
+        if mode != "no_output":
+            target.parent.mkdir()
+            target.write_text("#!/bin/sh\n")
+            target.chmod(0o755)
+
+    monkeypatch.setattr(init.subprocess, "run", run)
+    args = ["--yes", "--compute", "local", "--target", "o/r", "--author-backend", backend]
+    if mode == "skip":
+        args.append("--no-install-harness")
+    rc = init.main(args)
+    if mode in ("failure", "no_output", "permission"):
+        assert rc == 1
+        assert "Run manually: bash " in capsys.readouterr().err
+        assert not (tmp_path / "config" / ".env").exists()
+    else:
+        assert rc == 0
+        env = (tmp_path / "config" / ".env").read_text()
+        assert (f"{init.author_bin_env(backend)}={target}" in env) == (mode != "skip")
+    assert len(calls) == (mode not in ("present", "skip"))
+    if mode == "missing":
+        monkeypatch.setattr(init, "locate_harness", lambda _: str(target))
+        assert init.main([*args, "--force"]) == 0
+        assert len(calls) == 1
+
+
+@pytest.mark.parametrize("valid", [True, False])
+def test_claude_checksum_gate(tmp_path, valid):
+    # Substitute only the test copy's pins, never the production verification
+    # or hash tool: a small executable stands in for the 227 MB release asset.
+    payload = b"#!/bin/sh\necho '2.1.272 (Claude Code)'\n"
+    asset = tmp_path / "asset"
+    asset.write_bytes(payload if valid else b"untrusted")
+    script = tmp_path / "installer.sh"
+    source = (ROOT / "scripts/install_claude.sh").read_text()
+    script.write_text(
+        re.sub(
+            r'WANT_SHA256="[0-9a-f]{64}"',
+            f'WANT_SHA256="{hashlib.sha256(payload).hexdigest()}"',
+            source,
+        )
+    )
+    shim = tmp_path / "shim"
+    shim.mkdir()
+    for name, body in {
+        "curl": '#!/bin/bash\nwhile [ "$1" != "-o" ]; do shift; done\ncp "$ASSET" "$2"\n',
+        "uname": '#!/bin/sh\ncase "$1" in -s) echo Linux;; -m) echo x86_64;; esac\n',
+    }.items():
+        path = shim / name
+        path.write_text(body)
+        path.chmod(0o755)
+    target = tmp_path / "installed" / "claude"
+    env = {**os.environ, "PATH": f"{shim}:{os.environ['PATH']}", "ASSET": str(asset)}
+    result = subprocess.run(
+        ["bash", str(script), str(target)], env=env, capture_output=True, text=True
+    )
+    assert (result.returncode == 0) == valid, result.stderr
+    assert target.exists() == valid
+    assert not list(tmp_path.rglob("*.tmp.*"))
+    if valid:
+        assert target.read_bytes() == payload
+        assert os.access(target, os.X_OK)
+        (shim / "curl").write_text("#!/bin/sh\nexit 99\n")
+        assert subprocess.run(["bash", str(script), str(target)], env=env).returncode == 0
+    else:
+        assert "sha256 mismatch" in result.stderr
+
+
+def _claude_provisioning_block(deploy: str) -> str:
+    start = deploy.index("# The configured author's CLI is a host prerequisite")
+    end = deploy.index("\nesac\n", start) + len("\nesac\n")  # the outer case, at column 0
+    return deploy[start:end]
+
+
+@pytest.mark.parametrize(
+    ("author", "present", "on_path", "recorded", "relative_path", "expected"),
+    [
+        (
+            "claude",
+            False,
+            False,
+            "",
+            False,
+            "default",
+        ),  # missing everywhere: install to ~/.local/bin
+        ("claude", True, False, "", False, ""),  # already under ~/.local/bin
+        ("claude", False, True, "", False, ""),  # already on PATH (absolute entry)
+        (
+            "claude",
+            False,
+            True,
+            "",
+            True,
+            "default",
+        ),  # only through a relative PATH entry: jobs cannot use it
+        (
+            "claude",
+            False,
+            True,
+            "stale",
+            False,
+            "recorded",
+        ),  # recorded path gone: PATH does not excuse it
+        ("claude", True, False, "present", False, ""),  # recorded path present
+        ("codex", False, False, "", False, ""),  # not the configured author
+    ],
+)
+def test_deploy_provisions_the_configured_author_cli(
+    tmp_path, author, present, on_path, recorded, relative_path, expected
+):
+    """The chain's deploy step runs the pinned claude installer only when the
+    configured author is claude and the CLI the jobs will use is missing: the
+    recorded path when there is one, else an absolute PATH hit or ~/.local/bin."""
+    home = tmp_path / "checkout"
+    (home / "scripts").mkdir(parents=True)
+    log = tmp_path / "calls"
+    (home / "scripts" / "install_claude.sh").write_text(f'#!/bin/bash\necho "claude $1" >> {log}\n')
+    userhome = tmp_path / "userhome"
+    (userhome / ".local" / "bin").mkdir(parents=True)
+    path_dir = tmp_path / "path"
+    path_dir.mkdir()
+    if present:
+        binary = userhome / ".local" / "bin" / "claude"
+        binary.write_text("#!/bin/sh\n")
+        binary.chmod(0o755)
+    if on_path:
+        binary = path_dir / "claude"
+        binary.write_text("#!/bin/sh\n")
+        binary.chmod(0o755)
+    env = {
+        "HOME": str(userhome),
+        "OUTERLOOP_HOME": str(home),
+        "OUTERLOOP_AUTHOR_BACKEND": author,
+        "PATH": f"{path_dir}:/usr/bin:/bin",
+    }
+    recorded_path = tmp_path / "recorded" / "claude"
+    if recorded == "present":
+        recorded_path.parent.mkdir()
+        recorded_path.write_text("#!/bin/sh\n")
+        recorded_path.chmod(0o755)
+    if recorded:
+        env["OUTERLOOP_CLAUDE_BIN"] = str(recorded_path)
+    if relative_path:
+        env["PATH"] = ".:/usr/bin:/bin"
+    block = _claude_provisioning_block((ROOT / "scripts/tick_deploy.sh").read_text())
+    subprocess.run(
+        ["/bin/bash", "-c", block],
+        env=env,
+        check=True,
+        capture_output=True,
+        text=True,
+        cwd=path_dir,
+    )
+    calls = log.read_text().splitlines() if log.exists() else []
+    want = {
+        "": [],
+        "default": [f"claude {userhome / '.local' / 'bin' / 'claude'}"],
+        "recorded": [f"claude {recorded_path}"],
+    }[expected]
+    assert calls == want
+
+
+@pytest.mark.parametrize(
+    ("author_bin", "github_app", "no_install", "wanted"),
+    [
+        ("", False, False, True),
+        ("/usr/local/bin/claude", False, False, False),
+        ("", True, False, False),  # the focused App run sets up the App only
+        ("", False, True, False),
+    ],
+)
+def test_cli_install_wanted(author_bin, github_app, no_install, wanted):
+    import argparse
+
+    args = argparse.Namespace(github_app=github_app, no_install_harness=no_install)
+    assert init.cli_install_wanted(author_bin, args) is wanted