outerloop-science 0.1.0.dev0__tar.gz → 0.1.0.dev2__tar.gz

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/.gitignore

@@ -31,3 +31,6 @@ outputs/
 
 # Cloudflare wrangler local cache (setup page deploys)
 .wrangler/
+
+# pytest-testmon's change-tracking database
+.testmondata

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/CHANGELOG.md

@@ -6,6 +6,82 @@ Versions follow [SemVer](https://semver.org).
 
 ## [Unreleased]
 
+### Added
+
+- `climb/status.json` carries the fleet's queue: the kernel's own Slurm jobs
+  (tick chain, sessions, wakes, evals, launches), each attributed to an agent,
+  with state, elapsed time, partition and submit time. Jobs on the account
+  that are not the kernel's never appear. The strip republishes when a job
+  appears, leaves, or changes state, not on elapsed drift.
+- `outerloop init` asks for the author's model API key (hidden) and writes it to
+  `~/.config/outerloop/<backend>_key` (0600), or takes `--author-key-file` for an
+  existing file (checked to exist, stored absolute); the `.env` records it as
+  `OUTERLOOP_<BACKEND>_KEY_FILE`. The key lands in the config dir in use:
+  `~/.config/outerloop/`, or `~/.config/autoresearch/` on a machine set up
+  before the rename. The focused `--github-app` run still asks nothing about
+  the author. Every secret `init` writes (keys, PAT, App PEM and JSON, `.env`)
+  is now created 0600 in one step rather than written and then tightened.
+- The agent image is published: `containers/agent-py312.def` is its recipe
+  (Ubuntu 24.04, Python 3.12, uv, git, build tools), the `build-image` workflow
+  builds and uploads it with a checksum to huggingface.co/outerloop-science/
+  agent-image on every recipe change, and `outerloop init` downloads it on
+  Linux when Apptainer is installed, so local mode runs contained by default
+  (`--image` names your own, `--no-image` opts out).
+- `outerloop init` checks that Apptainer can actually run a container before
+  downloading the image (on Ubuntu 24.04 a hand-installed Apptainer is on PATH
+  but cannot create user namespaces), and when it cannot, prints the install
+  steps for the machine's distribution and continues uncontained. The image
+  download shows a progress bar with size, speed and ETA on a terminal, one
+  line per 10% otherwise, and confirms the checksum. `docs/install.md` gains
+  an "Installing Apptainer" section.
+- Launch admission: with `OUTERLOOP_MAX_LAUNCH_GPUS` set to the per-user GPU
+  cap, author launches are submitted held and the tick releases them
+  oldest-first while the user's GPU jobs fit under the cap, cancels held
+  launches of runs that have ended, and stops releasing when Slurm parks a
+  released launch on a per-user reason. `squeue` rows on the board carry the
+  pending reason and GRES. Unset, launches queue as before.
+
+### Changed
+
+- The board's queue is a card in the live strip, not a preformatted dump: a
+  full-width table with running jobs first, state pills, elapsed time,
+  partition (first of several, the rest counted, all on hover), and the
+  owning agent in its color; long job names are cut with an ellipsis and
+  shown whole on hover.
+- The Claude author's key follows the same rule as Codex's: the file is
+  `~/.config/outerloop/claude_key` and the setting `OUTERLOOP_CLAUDE_KEY_FILE`.
+  The pre-rename `harness_key` file and `*_HARNESS_KEY_FILE` setting are still
+  read (the new name wins when both exist), so an existing setup keeps working.
+- `AUTORESEARCH_TARGET` is required for in-review servicing (follow-ups, wakes,
+  the board). The kernel no longer falls back to the retired
+  `agentic-learning-ai-lab/autoresearch-pilot` repo when it is unset; the tick
+  logs the missing setting like any other.
+- The test suite runs on all cores by default (pytest-xdist), about four times
+  faster locally; `pytest --testmon` runs only the tests affected by your edits
+  (pytest-testmon). Tier selection moved from `addopts` into `tests/conftest.py`
+  (a `-m` in `addopts` disables testmon), and a `serial` tier holds the tests
+  that inspect the process table: skipped while workers run, and `pytest -m
+  serial` turns workers off, so the tier always runs alone (CI's second step).
+- The kernel reads `OUTERLOOP_*` everywhere: every internal read, log line,
+  chain script and test now uses the public names. The pre-rename
+  `AUTORESEARCH_*` names are still accepted for one release, bridged at the
+  process boundary, the `.env` file and the chain scripts, and will be
+  dropped in the release after 0.1. The review footer names `outerloop`, and
+  `outerloop --version` exists; `start`, `tick` and `init` describe themselves
+  and every flag in `--help`.
+- The on-disk and queue names follow the rename: the resident tick job is
+  `outerloop-resident` (the per-cadence chain `outerloop-tick`), the local
+  state root defaults to `~/.outerloop`, the default image path is
+  `~/outerloop-images/agent-py312.sif`. `outerloop start` refuses while a
+  pre-rename `autoresearch-resident` is queued or running, since Slurm's
+  singleton serializes by name; cancel it first. An existing `~/.autoresearch`
+  or `~/autoresearch-images/` is used while the new path does not exist. A
+  chain-mode deployment (manual `tick_chain.sbatch`) must be stopped with
+  `scancel --name autoresearch-tick` before deploying this version. Every
+  honored pre-rename name (`~/.config/autoresearch/`, `.autoresearch.yaml`, the
+  `.autoresearch` channel dir, the old root, image and job names) is dropped in
+  the release after 0.1; the comment marker keeps recognizing old comments.
+
 ### Changed
 
 - The syscall channel dir in a workspace is now `.outerloop/` (the tool, the
@@ -51,9 +127,74 @@ Versions follow [SemVer](https://semver.org).
 
 ### Fixed
 
+- `outerloop init --github-app` says what to do at each step: which page
+  opens, which button to click, where the code appears, how to install the
+  App on the repository, and that the last step checks write access. It also
+  asks whether to create the App under your account or an organization,
+  which before needed the undocumented `--org` flag.
+- The App flow's final write check asked GitHub a question installation
+  tokens cannot answer, so it warned about a missing push permission on Apps
+  that could push. It now checks the installation's repository list and its
+  granted permissions.
+- `init --github-app` records the App's login (`<slug>[bot]`) as
+  `OUTERLOOP_BOT_LOGIN`. Without it the kernel fell back to a built-in
+  default that is not the adopter's identity and did not recognize its own
+  pull requests.
+- The local loop launches attempts without a container image. On a machine
+  with no Apptainer image, `AUTORESEARCH_COMPUTE=local` now brings up
+  servicing with an empty image, logs once that sessions run under the
+  harness's own sandbox and evaluations run bare on that machine, and passes
+  `--uncontained` to its jobs. The panel is off in that mode unless
+  `OUTERLOOP_PANEL_UNCONTAINED=1` opts in, and says so when it runs. Slurm
+  still requires the image, and so does a Codex author in every mode (#289).
+- The PyPI description no longer refers to the lab.
+- A base-synced re-measurement is finished instead of abandoned. The parked
+  stage recorded the session's local merge of the moved base as its parent,
+  a commit GitHub never saw, so the resume judged the PR head as "moved" on
+  every base-synced park and threw the landed result away. The stage now
+  records the PR head at park and the resume compares against that. An
+  abandon also releases the wake-attempt cap, so the "ask again" it invites
+  can be served.
+- A follow-up re-measurement that has landed is now finished even when the
+  run has spent its wake-attempt cap. The sessions that sync a stale PR onto
+  the moved base and dispatch the measurement each bill an attempt, so a
+  measurement could complete with nobody left to push its number; the run then
+  idled with "follow-up attempts without progress" every tick. The finishing
+  follow-up has its own allowance of `MAX_WAKE_ATTEMPTS`, counted on the
+  stage, so a session that fails to finish is retried a bounded number of
+  times; the cap still holds for follow-ups that have nothing landed to finish.
 - `outerloop init` no longer overwrites an existing `~/.config/autoresearch/.env`
   silently: interactively it asks; with `--yes` it refuses unless `--force` is
   passed. The check runs before any GitHub App is created.
+- Slurm account and partition are both optional (#300). `outerloop start`
+  no longer requires an account, `outerloop init` no longer insists on one,
+  the tick's in-review servicing and the attempt's resume and dispatch gates
+  need only the image, and every sbatch the kernel builds passes `--account`
+  and `--partition` only when set, so Slurm bills the caller's default
+  association and picks its default partition.
+- A launch still queued past its deadline is no longer cancelled and woken as
+  "unschedulable" when Slurm's pending reason is a wait: a busy queue
+  (Priority, Resources), a reservation or dependency, or the account's own
+  per-user/per-account/group cap (`QOSMaxGRESPerUser` and kin). The sweep
+  extends the deadline by one slack window and logs the reasons; a queued job
+  keeps its priority age, where a re-launch would start over at the back.
+  Reasons that never clear (a dependency that cannot be satisfied, per-job
+  limits, an invalid account or QOS, a held job) still cancel and wake.
+- `outerloop init` stops with exit 1 when the credential cannot open pull
+  requests on the target (401, 403, 404, or no write access) instead of
+  printing a warning and `next: outerloop start` (#285); a network failure stays
+  a warning. The PAT path records the token's login as `OUTERLOOP_BOT_LOGIN`,
+  and the tick warns when the login is unset and the lab default applies (#298).
+- `init` locates the author's CLI (`claude`/`codex`) on PATH or in
+  `~/.local/bin`, records it as `OUTERLOOP_CLAUDE_BIN`/`OUTERLOOP_CODEX_BIN`, and
+  says how to install it when absent; `attempt --claude-bin` honors that
+  setting; `start` refuses to launch when a recorded binary is missing; a
+  `spawn-error` names the binary and the OS error (#294).
+- Local jobs keep their combined stdout/stderr in `local_jobs/<id>.out` beside
+  the state file, and the log line names it when the job did not complete (#295).
+- `cryptography` is a base dependency, so the GitHub App identity works from a
+  plain `pip install`; the `app-auth` extra is now a no-op (#293). The `tick`
+  subcommand's help no longer uses lab-internal vocabulary (#286).
 
 ### Added
 

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/CLAUDE.md

@@ -8,7 +8,7 @@ Scaffold phase — `docs/roadmap.md` says what exists vs. planned;
 
 ```bash
 uv sync
-uv run pytest                                    # slow/llm/slurm excluded by default
+uv run pytest                                    # all cores; --testmon = only tests affected by your edits
 uv run ruff check --fix . && uv run ruff format .
 uv run mypy
 uv run pre-commit run --all-files

outerloop_science-0.1.0.dev2/CONTRIBUTING.md

@@ -0,0 +1,89 @@
+# Contributing
+
+Outerloop is developed in the open by the [Agentic Learning AI Lab](https://agenticlearning.ai)
+at NYU, and its own agents are regular contributors to it. Contributions from
+people are welcome too: bug reports, fixes, documentation, new compute
+backends, and benchmark contracts for your own repos.
+
+## Before you start
+
+- Look through the open issues. For anything larger than a small fix, open an
+  issue first so we can agree on the shape before you write code.
+- Security problems go to the contact in [SECURITY.md](SECURITY.md), not to a
+  public issue.
+
+## Setup
+
+```bash
+uv sync
+uv run pre-commit install
+uv run pytest
+```
+
+## Making a change
+
+1. Branch from `main`: `fix/<topic>` or `feat/<topic>`.
+2. Keep the change focused. Add or update tests, and a line under
+   `[Unreleased]` in `CHANGELOG.md` for anything a user would notice.
+3. Run the same gate CI runs before you push:
+
+   ```bash
+   uv run pre-commit run --all-files   # lint, formatting, secret scan
+   uv lock --check
+   uv run mypy
+   uv run pytest && uv run pytest -m serial
+   ```
+
+4. Open a pull request against `main`. Say what changed, why, and how you
+   verified it.
+
+## What happens to your pull request
+
+- CI must pass.
+- One of our agents reviews it and posts its findings as a review, usually
+  within the hour; no time is guaranteed. It never approves or blocks; a
+  maintainer decides. Fix what is right and reply to what is not; findings
+  answered with a reason are fine. After you push fixes, a maintainer removes
+  and re-adds the `outerloop:review` label to run another round.
+- The agent review runs only for branches in this repository. A pull request
+  from a fork gets CI but no agent review; a maintainer can push your branch
+  here to run one.
+- A maintainer merges with a merge commit. We do not squash or rebase, so the
+  history of how a change came to be stays intact. Keep your branch current
+  with `git merge main`, and never force-push a branch someone else has seen.
+
+## Conventions
+
+- Python 3.12, absolute imports (`from outerloop ...`), and code that works
+  from the installed wheel; no paths relative to a checkout.
+- `ruff` for lint and formatting (line length 100); `mypy` clean.
+- Dependencies go in the `pyproject.toml` group that owns them, then
+  `uv lock`; CI checks the lock.
+- Docs are plain prose. Short sentences, no metaphors, no internal jargon.
+
+## Tests
+
+| Tier | Marker | Runs |
+| --- | --- | --- |
+| unit | *(none)* | CI, every PR, on all cores |
+| serial | `serial` | CI, second step: `pytest -m serial` (inspects the process table) |
+| slow | `slow` | nightly or manual |
+| llm | `llm` | manual only, paid APIs |
+| slurm | `slurm` | manual only, needs a cluster |
+
+While editing, `uv run pytest --testmon` runs only the tests affected by your
+change; `uv run pytest -n0` runs everything serially.
+
+## Pull requests from the agents
+
+Pull requests authored by `outerloop-science[bot]` are the system improving
+the repositories it works on. They appear on those target repositories and are
+skipped by the advisory reviewer by design. What gates them is each target's
+own rules: its required human review, or, where a target's contract allows
+automatic merging, the measurement gate and review panel that ran before the
+PR opened. This document is about contributing to Outerloop, this repository.
+
+## License
+
+By contributing you agree that your contributions are licensed under the
+[Apache License 2.0](LICENSE), the same as the project.

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: outerloop-science
-Version: 0.1.0.dev0
-Summary: Autonomous research agent that co-develops the lab's benchmark-bearing repos
+Version: 0.1.0.dev2
+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
 Project-URL: Changelog, https://github.com/outerloop-science/outerloop/blob/main/CHANGELOG.md
@@ -11,10 +11,10 @@ License-Expression: Apache-2.0
 License-File: LICENSE
 License-File: NOTICE
 Requires-Python: >=3.12
+Requires-Dist: cryptography>=42
 Requires-Dist: pydantic>=2
 Requires-Dist: pyyaml>=6
 Provides-Extra: app-auth
-Requires-Dist: cryptography>=42; extra == 'app-auth'
 Description-Content-Type: text/markdown
 
 <picture>
@@ -56,18 +56,22 @@ themselves.
 
 ## Get started
 
-Three commands and two files: your model key and the contract. You need a repo
-with a benchmark command, a model API key (Anthropic by default), and a Slurm
-cluster or one machine with a GPU.
+Three commands and one file. You need a repo with a benchmark command, an API
+key for the model that will write the code, and a Slurm cluster or one machine
+with a GPU.
 
 ```bash
 pip install outerloop-science
-outerloop init     # where the loop runs, which repo, your GitHub bot; writes the config
+outerloop init     # where the loop runs, which repo, which model and its key, your GitHub identity
 ```
 
-Put your Anthropic API key in `~/.config/outerloop/harness_key`: one line,
-readable only by you (`chmod 600`). Then add one file, `.outerloop.yaml`, to
-the repo you want improved:
+The wizard asks for a GitHub identity for the agents to open pull requests
+as. Pick `app` and it walks you through creating a GitHub App, under your
+account or under an organization you name, and installing it on the repo:
+two browser pages and a code pasted back. It then checks that the App can
+write the repo and tells you if it cannot. Pick `pat` if you already have a
+token. It writes the config and the key files; nothing to edit by hand. Then
+add one file, `.outerloop.yaml`, to the repo you want improved:
 
 ```yaml
 benchmarks:

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/README.md

@@ -37,18 +37,22 @@ themselves.
 
 ## Get started
 
-Three commands and two files: your model key and the contract. You need a repo
-with a benchmark command, a model API key (Anthropic by default), and a Slurm
-cluster or one machine with a GPU.
+Three commands and one file. You need a repo with a benchmark command, an API
+key for the model that will write the code, and a Slurm cluster or one machine
+with a GPU.
 
 ```bash
 pip install outerloop-science
-outerloop init     # where the loop runs, which repo, your GitHub bot; writes the config
+outerloop init     # where the loop runs, which repo, which model and its key, your GitHub identity
 ```
 
-Put your Anthropic API key in `~/.config/outerloop/harness_key`: one line,
-readable only by you (`chmod 600`). Then add one file, `.outerloop.yaml`, to
-the repo you want improved:
+The wizard asks for a GitHub identity for the agents to open pull requests
+as. Pick `app` and it walks you through creating a GitHub App, under your
+account or under an organization you name, and installing it on the repo:
+two browser pages and a code pasted back. It then checks that the App can
+write the repo and tells you if it cannot. Pick `pat` if you already have a
+token. It writes the config and the key files; nothing to edit by hand. Then
+add one file, `.outerloop.yaml`, to the repo you want improved:
 
 ```yaml
 benchmarks:

outerloop_science-0.1.0.dev2/containers/README.md

@@ -0,0 +1,8 @@
+# containers
+
+`agent-py312.def` is the Apptainer recipe for the image the kernel runs sessions and
+evaluations in. The `build-image` workflow builds it on every change to this directory and
+on manual dispatch, and publishes the result to
+[huggingface.co/outerloop-science/agent-image](https://huggingface.co/outerloop-science/agent-image)
+with a checksum. `outerloop init` downloads it on Linux when Apptainer is installed; the
+tick reads `~/outerloop-images/agent-py312.sif` unless `OUTERLOOP_IMAGE` says otherwise.

outerloop_science-0.1.0.dev2/containers/agent-py312.def

@@ -0,0 +1,43 @@
+# The Outerloop agent image: what a contained session and a dispatched
+# evaluation see. The kernel binds the workspace, a per-run home and the
+# harness binary (claude/codex) into it; --nv adds the host's GPU driver for
+# GPU benchmarks. So the image only has to provide the base a target's own
+# `uv run ...` needs: Python 3.12, uv, git and a compiler.
+#
+# Built by .github/workflows/build-image.yml and published to
+# https://huggingface.co/outerloop-science/agent-image; `outerloop init` pulls
+# it on Linux. Build by hand: apptainer build agent-py312.sif containers/agent-py312.def
+
+Bootstrap: docker
+From: ubuntu:24.04
+
+%post
+    set -eu
+    export DEBIAN_FRONTEND=noninteractive
+    apt-get update
+    apt-get install -y --no-install-recommends \
+        ca-certificates curl git git-lfs openssh-client \
+        build-essential pkg-config \
+        python3 python3-venv python3-dev \
+        libgomp1 libglib2.0-0 procps less unzip zip jq ripgrep
+    rm -rf /var/lib/apt/lists/*
+    # uv installs its own Pythons when a target pins one; the system 3.12 is the default
+    curl -LsSf https://astral.sh/uv/install.sh | env UV_INSTALL_DIR=/usr/local/bin INSTALLER_NO_MODIFY_PATH=1 sh
+    ln -sf /usr/bin/python3 /usr/local/bin/python
+    git lfs install --system
+    python3 --version && uv --version && git --version
+
+%environment
+    export LC_ALL=C.UTF-8
+    export LANG=C.UTF-8
+    export PATH=/usr/local/bin:/usr/local/sbin:/usr/sbin:/usr/bin:/sbin:/bin
+
+%labels
+    org.opencontainers.image.title outerloop agent image
+    org.opencontainers.image.source https://github.com/outerloop-science/outerloop
+    outerloop.recipe containers/agent-py312.def
+
+%help
+    Outerloop agent image: Ubuntu 24.04, Python 3.12, uv, git, build tools.
+    The kernel runs sessions and evaluations in it with --containall --cleanenv,
+    binding only the workspace, a per-run home and the harness binary.

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/docs/design/architecture.md

@@ -371,8 +371,12 @@ failure can strand a run:
    `deadline = submit_time + walltime + slack` (recomputed from `start_time`
    once the job starts, so late scheduling never truncates a healthy run).
    Past the deadline the sweep consults `sacct` and acts on what it finds:
-   still PENDING → the experiment is unschedulable in practice; cancel it and
-   wake the run with that fact. No record on a *successful* query → the job
+   still PENDING → ask squeue why: a wait (Priority/Resources, a reservation
+   or dependency, the account's own per-user/group cap such as
+   `QOSMaxGRESPerUser`) moves the deadline out by one slack window, since a
+   queued job keeps its priority age and a re-launch would start over; any
+   other reason means unschedulable in practice — cancel it and wake the
+   run with that fact. No record on a *successful* query → the job
    vanished; wake with that fact. Query failed or timed out → that is
    "Slurm unknown", never "job gone" — defer to the next tick, and only a
    sustained outage (its own alert via the watchdog) escalates. A fail-safe

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/docs/design/dispatcher.md

@@ -66,7 +66,7 @@ orchestrator chooses per eval site, not per repo.
 launches alike: the JobSpec requests `--gpus=N`, and the jail adds `--nv` so
 the allocation is visible inside the container; nothing else about the
 containment changes. GPU jobs need their own lane, so the deployment names
-one — `AUTORESEARCH_GPU_PARTITION`, optionally `AUTORESEARCH_GPU_ACCOUNT`
+one — `OUTERLOOP_GPU_PARTITION`, optionally `OUTERLOOP_GPU_ACCOUNT`
 (default: the CPU account) — and a benchmark with `gpus > 0` on a deployment
 without a lane is REFUSED at launch (both attempt lanes), never queued into
 evals that can never run. GPUs exist only on DISPATCHED jobs: the contract
@@ -76,6 +76,18 @@ benchmarks outright for now — a stewardship validates its rewrite in-job.
 The first target in this shape is the speedrun (`gpt-speedrun`: one H200
 per eval, ~3.5h).
 
+**Launch admission.** A per-user GPU cap (a QOS's `MaxTRESPerUser`, 16 on
+Torch) means the fleet can run only so many launches at once, whatever the
+agent count: six 8-GPU launches queued against a 16-GPU cap left four pending
+for a day on `QOSMaxGRESPerUser`. With `OUTERLOOP_MAX_LAUNCH_GPUS` set to that
+cap, author launches are submitted HELD, and every tick `service_admission`
+releases them oldest-first while the user's eligible GPU jobs (evals and
+launches alike) fit under the cap; held launches whose run has since ended
+are cancelled. A released launch that Slurm parks on a per-user reason means
+the cap is set too high, and nothing more is released that tick. The wake's
+`afterany` dependency is unchanged (held jobs are pending), and the sweep
+treats the kernel's hold as a wait. Unset, launches queue as submitted.
+
 **Who decides the eval walltime.** The gate measures steps, not time, so
 walltime should bound only SPEND — and the attempt already has a spend
 budget. The contract's `eval_minutes` is the DEFAULT; the author may declare
@@ -234,9 +246,12 @@ dies -> the `eval-error` outcome at wake (ending `aborted`, exactly as the
 in-job eval failure maps today); a LOST wake -> the sweep's primary backup,
 which wakes any run whose job reads terminal after the grace period —
 plus GONE past the deadline (vanished) and PENDING past the deadline
-(cancel, then wake as unschedulable); a still-RUNNING job is deliberately
+(when Slurm's reason is a wait — a busy queue, a reservation or dependency,
+the account's own per-user/group cap — the deadline moves out by one slack
+window; otherwise cancel, then wake as unschedulable); a still-RUNNING job is deliberately
 left alone, bounded by its own walltime; wakes that fire without producing
-progress -> `stuck` at MAX_WAKE_ATTEMPTS. A moved base during the wait is
+progress -> `stuck` at MAX_WAKE_ATTEMPTS (a landed re-measure has its own
+allowance of MAX_WAKE_ATTEMPTS finishing follow-ups, counted on the stage). A moved base during the wait is
 review's to handle — the sealed candidate publishes as-is (research-loop.md:
 a stale PR is a re-wake, never an orchestrator auto-merge). Worktree cleanup has a named owner at every exit: the
 wake's own finally (primary, as in-job measures do today), the sweep's
@@ -286,7 +301,7 @@ GPU benchmarks and portfolio climbs both multiply eval load; both were
 designed against this seam. Portfolio's N concurrent climbs become N
 waiting records with independent wakes — the serialization question stays
 in the picker, not the dispatcher. The tick's job-partition knobs
-(`AUTORESEARCH_JOB_PARTITION`) already route work jobs; per-benchmark
+(`OUTERLOOP_JOB_PARTITION`) already route work jobs; per-benchmark
 partition/GPU allocation fields are a phase-3 contract-schema change
 (`Benchmark` rejects unknown fields today, deliberately), validated and
 clamped by operator ceilings like every other budget.

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/docs/design/github-app-auth.md

@@ -108,7 +108,7 @@ Swapping the live fleet's identity mid-campaign is an ops event:
 
 ## The flag
 
-`AUTORESEARCH_GITHUB_APP_FILE` names a JSON config —
+`OUTERLOOP_GITHUB_APP_FILE` names a JSON config —
 
 ```json
 {"app_id": 1234, "installation_id": 5678,
@@ -117,13 +117,13 @@ Swapping the live fleet's identity mid-campaign is an ops event:
 
 — and rides the rails the PAT already rides: role CLIs default their
 `--github-app-file` from it (jobs inherit the tick's environment, the same
-way `AUTORESEARCH_AUTHOR_*` reaches them), and every bot-auth construction
+way `OUTERLOOP_AUTHOR_*` reaches them), and every bot-auth construction
 goes through one factory, `appauth.resolve_bot_auth(pat_file, app_file)`:
 App provider when the config is set, PAT otherwise. Revert = unset the env
 var. The ids are not secrets; the key path inside keeps PAT-file custody
 (600, never committed).
 
-The identity flips WITH the credential: `AUTORESEARCH_BOT_LOGIN` names the
+The identity flips WITH the credential: `OUTERLOOP_BOT_LOGIN` names the
 login the kernel now posts as (`<app-slug>[bot]`, e.g.
 `outerloop-autoresearch[bot]`), read by every role through one
 `github.bot_login_from_env()` default. Every own-comment filter, alarm-issue
@@ -135,10 +135,10 @@ Everything the kernel created BEFORE the flip carries the old login — the
 research-log issue, contract alarms, intake claims, its PRs. Recognition is
 keyed on login on purpose (the markers are public strings anyone can paste),
 so a flip must widen the set of our logins, not loosen the check:
-`AUTORESEARCH_BOT_ALIASES=agentic-learning-bot` names the former identity,
+`OUTERLOOP_BOT_ALIASES=agentic-learning-bot` names the former identity,
 and every "is this ours" gate goes through `github.is_own_login`. The
 reusable review and verify workflows take the same value as a `bot_aliases`
-input (exported as `AUTORESEARCH_BOT_ALIASES`; the verifier's author gate
+input (exported as `OUTERLOOP_BOT_ALIASES`; the verifier's author gate
 accepts an alias too), so a target repo passes `bot_login` = the App login and
 `bot_aliases` = the former account. Live lesson: without it, the first tick
 under the App claimed the kernel's own research-log issue as a research order.

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/docs/design/headline.md

@@ -61,7 +61,7 @@ monitoring agent + ~100 interventions; AIDE: in-process tree search). Ours is
 **decentralized on Slurm**: no resident daemon — a self-perpetuating chain of
 ~16 s stateless ticks; all state in typed records on the shared FS; every
 role (author session, eval, panel judge, wake) its own Slurm job — wake
-dispatch sits behind an operator flag (`AUTORESEARCH_DISPATCH_WAKE`, on in
+dispatch sits behind an operator flag (`OUTERLOOP_DISPATCH_WAKE`, on in
 our deployment since 2026-08-20; retiring the dark-launch flag to
 default-on is a listed cleanup); crash or preemption anywhere heals
 through the sweep into honest endings.

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/docs/design/onboarding.md

@@ -34,8 +34,9 @@ non-interactive use):
   discovers the installation id itself (App JWT → `GET /app/installations`).
   A pre-existing PAT path is accepted as the alternative for orgs that
   prefer it.
-- **Collect the author key.** One path prompt per configured backend
-  (`OUTERLOOP_HARNESS_KEY_FILE` / codex equivalent), mode-600 enforced.
+- **Collect the author key.** A hidden paste for the configured backend,
+  written to `~/.config/outerloop/<backend>_key` (0600) and recorded as
+  `OUTERLOOP_<BACKEND>_KEY_FILE`; `--author-key-file` for an existing file.
 - **Write `~/.config/outerloop/.env`** — only keys the operator chose;
   the tick chain's allowlist is the contract for what matters.
 - **Doctor.** Re-run every check the tick already preflights, plus the

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/docs/design/resident-tick.md

@@ -1,7 +1,7 @@
 # The resident tick
 
 *Design note, 2026-09-02. Status: built as the opt-in mode
-(`AUTORESEARCH_RESIDENT=1`, `scripts/tick_resident.sh`); the chain restarts of
+(`OUTERLOOP_RESIDENT=1`, `scripts/tick_resident.sh`); the chain restarts of
 2026-09-02 are the evidence.*
 
 ## The problem
@@ -91,16 +91,16 @@ covers it.
 
 ## Rollout
 
-1. Opt-in mode in `scripts/tick_chain.sbatch`: `AUTORESEARCH_RESIDENT=1` in
+1. Opt-in mode in `scripts/tick_chain.sbatch`: `OUTERLOOP_RESIDENT=1` in
    the chain's environment selects the loop; unset keeps the per-cadence
    chain. The walltime is fixed by Slurm before the script runs, so the
    resident chain is STARTED with an explicit walltime and its own job name:
 
    ```
-   sbatch --time=360 --job-name=autoresearch-resident --dependency=singleton \
+   sbatch --time=360 --job-name=outerloop-resident --dependency=singleton \
      --account=… --partition=cpu_short \
-     --export=ALL,AUTORESEARCH_RESIDENT=1,AUTORESEARCH_HOME=…,AUTORESEARCH_ROOT=…,\
-   AUTORESEARCH_ACCOUNT=…,AUTORESEARCH_PARTITION=cpu_short,AUTORESEARCH_PAT_FILE=… \
+     --export=ALL,OUTERLOOP_RESIDENT=1,OUTERLOOP_HOME=…,OUTERLOOP_ROOT=…,\
+   OUTERLOOP_ACCOUNT=…,OUTERLOOP_PARTITION=cpu_short,OUTERLOOP_PAT_FILE=… \
      scripts/tick_chain.sbatch
    ```
 

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/docs/design/reviewer-infra.md

@@ -334,3 +334,27 @@ the same infrastructure the fork-PR phase needs.
 Re-test on version bumps: whether Claude's `Read` opens `/proc`, a hermes
 read-only toolset, a codex sandbox that hides `/proc`, or a runner that grants
 PID namespaces would each rewrite this section.
+
+## Maintainers: how many review rounds
+
+The advisory reviewer runs on open; a maintainer re-runs it after a fix by
+removing and re-adding the `outerloop:review` label once the push has
+settled (the workflow fires on the labeled event). Only the most recent round,
+run against the head commit, counts; a quiet verdict on an older diff
+authorizes nothing. Findings rejected on rationale get a reply on the thread.
+
+Termination is judged, not literal, because an eager reviewer can always find
+one more wording nit:
+
+- code PRs iterate until a round yields no new medium-or-higher or
+  behavior-affecting finding; wording nits in an otherwise quiet round are
+  fixed or answered without another round;
+- docs and process PRs get one round, its nits batched into one fix;
+- hard cap of four rounds: still finding mediums by then means the change is
+  the problem; stop and rethink rather than cycle.
+
+The habit exists because later rounds have repeatedly found real defects in
+earlier rounds' own fixes. Bot-authored improvement PRs sit outside this gate:
+the reviewer skips them by design, and their gate is the target repo's
+required human review (the publish step arms auto-merge only when the target's
+branch protection requires one).

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev2}/docs/design/role-cli.md

@@ -40,7 +40,7 @@ The invariants, proven on #132/#133 and non-negotiable everywhere:
    in the same PR — never two ways to say the same thing.
 4. **Verbs are RoleSpec-gated.** The RoleSpec already caps each role's
    tools/scope/key; the CLI's live verbs are part of that cap. It is ONE tool
-   (`.autoresearch/syscall`) whose verbs the brief exposes per role — an author
+   (`.outerloop/syscall`) whose verbs the brief exposes per role — an author
    uses `launch`/`sleep`, a judge uses `finding`/`conclude` — and a syscall is
    TYPED, so the kernel dispatches by type (a sleep parks + wakes; a verdict is
    read back). Every role runs the tool the same way: a shell in the jail. Roles
@@ -49,7 +49,7 @@ The invariants, proven on #132/#133 and non-negotiable everywhere:
 
 ## End-state
 
-One `.autoresearch/syscall` tool, its live verbs gated per role by RoleSpec:
+One `.outerloop/syscall` tool, its live verbs gated per role by RoleSpec:
 
 | Role | Verbs | Win | Installed where |
 | --- | --- | --- | --- |
@@ -70,7 +70,7 @@ lands with tests, and deletes what it replaces.
 ### Phase 0 — finish Phase A (in flight, prerequisite)
 
 The wake for `author-sleep` parks: gather each launch's results from the run
-dir, deliver declared artifacts into `.autoresearch/results/<name>/`, resume
+dir, deliver declared artifacts into `.outerloop/results/<name>/`, resume
 the **same session** through the climb's resume-entry (#129) with the results
 data-fenced, update the budget file. (The transitional `AUTHOR_SLEEP_WAKE_READY`
 constant and env-flag arming have since retired: enablement is contract-driven.) Plus
@@ -95,7 +95,7 @@ findings drafts the PR for a human. A submit costs the sleep it rides on.
 
 A verdict is not a second tool — it is a syscall TYPE on the one surface.
 Reviewer/verifier/panel stop emitting one schema-constrained final message.
-Instead: `python .autoresearch/syscall finding --file --line --confidence
+Instead: `python .outerloop/syscall finding --file --line --confidence
 --summary --detail [--blocking] [--kind] [--category]` per finding, then
 `... conclude --notes ...` to commit — each call validated on the spot, the
 verdict assembled kernel-side (`type: "verdict"`), well-formed by construction.