outerloop-science 0.1.0.dev3__tar.gz → 0.1.1__tar.gz

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/CHANGELOG.md

@@ -6,8 +6,112 @@ Versions follow [SemVer](https://semver.org).
 
 ## [Unreleased]
 
+## [0.1.1] - 2026-09-11
+
+### Fixed
+
+- Wakes never recorded a launch as ended. A nested `import time` in the wake function shadowed the module import, so the ledger step failed on every wake, and the failure was only logged to a stderr the scheduler discards. The PR's experiments table stayed empty and `history` showed every launch as not back. The nested imports are gone, the best-effort wrapper now logs the redacted traceback, and a wake writes its kernel log to `runs/<run>/kernel.log`.
+
+### Changed
+
+- The PyPI project page and the Python-version badge now read correctly: the package metadata lists the supported Python version (3.12) and the project's audience and topic. The README's Python badge is a static `3.12+` so it renders regardless of the release's metadata.
+
+### Deprecated
+
+- The `AUTORESEARCH_*` environment names and `.autoresearch` paths are still accepted. The 0.1.0 notes said they would go in 0.1.1; a bug-fix release should not also break a deployment's environment, so their removal moves to 0.2.0.
+
+## [0.1.0] - 2026-09-10
+
+The first release of Outerloop — autoresearch agents that improve your benchmark
+on your own code, your keys, and your compute. Built and used daily by the
+Agentic Learning AI Lab at NYU.
+
+### Highlights
+
+- **The loop.** An agent proposes a change, runs the experiment on your cluster,
+  measures it against the base tree at the same seed, and opens a pull request
+  only when the benchmark actually improves. Every attempt gets a short report,
+  negative results included.
+- **Verification first.** Outerloop re-measures every claim against the
+  repository's contract — it never trusts a number the agent reports — and a
+  reviewer panel reads the change and the claim before a pull request stands.
+- **Your guardrails apply.** Agents cannot touch the benchmark, the budgets, or
+  your CI; your branch protection and required checks apply to them as to any
+  contributor. A pull request waits for a human by default; a repo can also let
+  clean ones merge themselves.
+- **Runs where you do.** Slurm or a single GPU machine, behind one compute seam.
+  Sessions run in a scrubbed sandbox, and your model key and bot credentials
+  never leave the job.
+- **Onboarding in a few commands.** `outerloop init` writes the config and sets
+  up auth (a per-adopter GitHub App, or a token), `outerloop start` runs the
+  loop, and `outerloop upgrade` moves a local install to the newest release. The
+  container image is pulled, not built.
+- **Contracts and the board.** A repo declares its benchmark, scope, and budgets
+  in `.outerloop.yaml`; the climb board publishes every attempt and its outcome,
+  and the ledger keeps the honest record — refusals and negatives included.
+- **Research lines and depth.** Each agent works its own line and reintegrates
+  the moving base; a run hibernates through long experiments and wakes to read
+  its results.
+- **Advisory review and a weekly digest.** The reviewer posts structured,
+  advisory findings on every pull request, and a weekly maintainer scan files a
+  codebase-health digest.
+
+The `AUTORESEARCH_*` environment names and `.autoresearch` paths from before the
+rename are still accepted in 0.1; 0.1.1 kept them (see its notes) and 0.2.0
+removes them. The full history since the first pre-release follows.
+
+### Changed
+
+- Install guide: a lab member who is not an org owner now has documented steps
+  for GitHub App auth — make the personal App public, request the install, an
+  org owner approves, then optionally transfer the App to the org — matching
+  what `init --github-app` prints on the personal-App fallback.
+- Docs: corrected stale `autoresearch` command and module paths left by the
+  rename (onboarding, author-syscalls, architecture, role-cli), refreshed the
+  architecture component map (`budget` → `limits`, `report` →
+  `progress`/`climbboard`), and documented the tick scheduling knobs
+  `OUTERLOOP_CADENCE_MIN`, `OUTERLOOP_MAX_JOB_MINUTES`, and
+  `OUTERLOOP_MIN_TICK_MINUTES` in the install guide.
+
+- The maintainer digest issue now carries the scan date in its title
+  (`Maintainer digest — YYYY-MM-DD`), so its freshness shows in the issue list.
+  The scan's long verdict and rejected-findings text now folds into a
+  collapsible block, keeping the top of the issue a short summary (title,
+  advisory line, counts).
+
+### Fixed
+
+- `outerloop init --github-app` no longer dead-ends a non-owner of an
+  organization. Creating an org-owned App needs org-owner rights, so GitHub
+  makes a personal App that will not install on the org repo by default. init
+  now detects that the App landed under a different account and prints the path
+  that works — make it public, request the install, have an org owner approve
+  it, then rerun `init --force --github-app` (and optionally transfer the App to
+  the org). The install-failure help names the same steps.
+
+### Fixed
+
+- The follow-up finalizer no longer gets stuck withholding a measured re-sync
+  when auto-merge is already off. Before pushing a re-measured head it confirms
+  the PR will not auto-merge by the PR's actual auto-merge state, rather than by
+  matching one error string — whose text varies with the repo's "Allow
+  auto-merge" setting and the token type — so a merge:manual repo under a GitHub
+  App token no longer re-withholds its successful re-measurements.
+
 ### Added
 
+- `outerloop upgrade`: one verb for a local install to move to the newest
+  release (`--pre` to track pre-releases), the local counterpart of the Slurm
+  resident tick's `OUTERLOOP_AUTO_UPDATE` policy. It runs `pip install --upgrade`,
+  reports the version change, and reminds you to restart the loop.
+- Base reintegration (docs/design/base-reintegration.md): when a research
+  line's base moves while it sleeps, its wake fetches the fresh base and tells
+  the agent to merge it and decide what to re-run — the same fetch-and-merge
+  the in-review conflict wake already uses, so a long depth run no longer
+  drifts behind sibling merges and opens a stale PR.
+- `docs/design/base-reintegration.md`: a proposal to keep a running line's
+  base current by re-pinning at each wake and to reconcile a PR whose base
+  moved after the run ended, with the owner's five decisions and the build order.
 - A weekly maintenance digest (`maintenance-agent.yml`, reusable; the kernel's
   own caller is `maintenance.yml`): read-only lens sessions scan a repository's
   default branch for dead pathways, duplicated logic, oversized modules, stale
@@ -649,6 +753,19 @@ Versions follow [SemVer](https://semver.org).
 
 ### Changed
 
+- CI and reusable-workflow Actions bumped to current majors: actions/checkout
+  v7, astral-sh/setup-uv v10, upload-artifact v7, download-artifact v8. The
+  single-name artifact downloads stay flat and the pattern download reads
+  recursively, so the review split is unaffected; the node24 runtime is on the
+  hosted runners.
+- The tick reads its run records once per phase instead of once per service: a
+  single snapshot after the mutation phase feeds the read services, and one
+  feeds the board pass. About twelve full run-directory scans per tick become
+  five, which matters under a large fleet (the 2026-09-03 disk pressure); the
+  freshness guards that re-read a single record are unchanged.
+- The maintenance scan gains an `architecture` lens: it proposes abstraction
+  simplifications and missing extension points (a new backend, benchmark, or
+  role should need zero kernel change), as decision-kind digest items.
 - Helpers shared across kernel modules are public in their owning module:
   `brief.code_fence`, `brief.cap`, `attempt.target_clone_url`,
   `attempt.stage_launch_job_ids`, `orchestrator.metric_from_output`,

outerloop_science-0.1.1/CITATION.cff

@@ -0,0 +1,17 @@
+cff-version: 1.2.0
+message: "If you use Outerloop in your research, please cite it."
+title: Outerloop
+abstract: >-
+  Outerloop runs AI agents on your own research code: an agent proposes a
+  change, runs the experiment on your cluster, and opens a pull request only when
+  your benchmark improves. Every claim is re-measured against the repository's
+  contract, every attempt is recorded, and it runs on your keys, your compute,
+  and your repositories.
+type: software
+authors:
+  - name: "Agentic Learning AI Lab, New York University"
+repository-code: "https://github.com/outerloop-science/outerloop"
+url: "https://outerloop.science"
+license: Apache-2.0
+version: 0.1.1
+date-released: "2026-09-11"

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: outerloop-science
-Version: 0.1.0.dev3
+Version: 0.1.1
 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
@@ -10,6 +10,11 @@ Author: Agentic Learning AI Lab, New York University
 License-Expression: Apache-2.0
 License-File: LICENSE
 License-File: NOTICE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.12
 Requires-Dist: cryptography>=42
 Requires-Dist: pydantic>=2
@@ -26,7 +31,7 @@ Description-Content-Type: text/markdown
 
 [![ci](https://github.com/outerloop-science/outerloop/actions/workflows/ci.yml/badge.svg)](https://github.com/outerloop-science/outerloop/actions/workflows/ci.yml)
 [![PyPI](https://img.shields.io/pypi/v/outerloop-science.svg)](https://pypi.org/project/outerloop-science/)
-[![Python](https://img.shields.io/pypi/pyversions/outerloop-science.svg)](https://pypi.org/project/outerloop-science/)
+[![Python](https://img.shields.io/badge/python-3.12+-blue.svg)](https://pypi.org/project/outerloop-science/)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 
 **Autoresearch agents that improve your benchmark.**

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/README.md

@@ -7,7 +7,7 @@
 
 [![ci](https://github.com/outerloop-science/outerloop/actions/workflows/ci.yml/badge.svg)](https://github.com/outerloop-science/outerloop/actions/workflows/ci.yml)
 [![PyPI](https://img.shields.io/pypi/v/outerloop-science.svg)](https://pypi.org/project/outerloop-science/)
-[![Python](https://img.shields.io/pypi/pyversions/outerloop-science.svg)](https://pypi.org/project/outerloop-science/)
+[![Python](https://img.shields.io/badge/python-3.12+-blue.svg)](https://pypi.org/project/outerloop-science/)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 
 **Autoresearch agents that improve your benchmark.**

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/RELEASING.md

@@ -8,8 +8,8 @@
 
 ## Cutting a release
 
-1. PR: bump `__version__` and move the `[Unreleased]` entries under the new
-   version. A dev or rc pre-release still bumps the version (PyPI never
+1. PR: bump `__version__`, set `CITATION.cff`'s `version` and `date-released`,
+   and move the `[Unreleased]` entries under the new version. A dev or rc pre-release still bumps the version (PyPI never
    accepts a version twice, so the next one is `.dev1`, `rc2`, ...) but leaves
    `[Unreleased]` in place until the final release.
 2. `git tag vX.Y.Z && git push origin vX.Y.Z`. The `release` workflow builds

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/docs/design/architecture.md

@@ -35,7 +35,7 @@ scope:
 roadmap: docs/roadmap.md
 ```
 
-The schema lives here (`autoresearch.contract`). The loader hard-codes invariants
+The schema lives here (`outerloop.contract`). The loader hard-codes invariants
 no YAML can override: `.github/`, the contract file itself, and the roadmap are
 always forbidden write paths; the contract is read from the default branch only;
 **autoresearch is never a valid target of itself**.
@@ -278,7 +278,7 @@ insights across all targets and must never be part of any public flip. Raw
 metrics stay in W&B; the notebook links to runs. No database or vector store —
 grep + recency + distillation until that provably fails.
 
-## Components (`src/autoresearch/`)
+## Components (`src/outerloop/`)
 
 | Module | Job |
 | --- | --- |
@@ -287,8 +287,8 @@ grep + recency + distillation until that provably fails.
 | `orchestrator` | Tick logic: sentinel, lease, task selection, session dispatch, state sync |
 | `compute` | sbatch/squeue submit-and-poll behind one interface |
 | `github` | Bot auth and push (orchestrator-side, after sessions end), PR/issue ops |
-| `budget` | Hard caps: $ per run, weekly $, GPU-hours, PRs per week; subscription backends metered by a session/token proxy |
-| `report` | Per-run research reports (takeaways + next steps), notebook writes + distillation, weekly digests, cost ledger, leaderboard history |
+| `limits` | Effective session and job limits — turns, session and job minutes — with each contract wish clamped into our `[floor, ceiling]`; the tick's `OUTERLOOP_MAX_JOB_MINUTES` floors here |
+| `progress` / `climbboard` | `progress` writes the human-readable benchmark-progress files into the target repo on each improvement PR; `climbboard` publishes the climb board — every ended attempt and its outcome, plus the ledger and views — to the target's `research-log` branch whenever runs end |
 
 ## Harness and context engineering
 
@@ -309,7 +309,7 @@ exactly what any given agent saw, and a bad run can be replayed from its brief:
 | Ruler: how the metric is computed, how claims get re-verified | target repo docs | fixed |
 | Lessons: distilled, bounded per-target lessons file | notebook `lessons/<target>.md` | hard cap |
 | Recent history: last N run reports for this target (incl. failures) | notebook `runs/<target>/` | hard cap, newest first |
-| Budget state: remaining GPU-hours/$/PRs this week | `budget` | fixed |
+| Budget state: remaining GPU-hours/$/PRs this week | tick weekly accounting | fixed |
 
 Everything else is deliberately absent: no other targets' data (cross-target
 separation), no raw transcripts (distillation instead), no maintainer-private

outerloop_science-0.1.1/docs/design/base-reintegration.md

@@ -0,0 +1,92 @@
+# Base reintegration: keeping a running line current, and reconciling its PR
+
+Status: proposal (2026-09-08). Extends `research-lines.md`, which owns the
+per-agent branch and the "merge main in at run start" rule. Prompted by a
+real case, PR #12 on gpt-speedrun.
+
+## The problem, concretely
+
+agent-04's line started 2026-09-04 in the morning. That evening a sibling
+merged #10, moving the record from 8192 to 7808. agent-04's line kept
+iterating on its own 8192-era base for three more days and opened PR #12
+claiming 7232, against a base that had been superseded on day one.
+
+The claim was real: 7232 came from setting `warmdown_iters` to 6400, the same
+knob #10 set to 4352, on a monotonic trend, and it holds against the current
+base. But the PR conflicted, and by the time it opened, the run had
+terminated, so nothing in the kernel could reconcile it. A human merged it by
+hand.
+
+Two gaps produced this:
+
+- A line merges main only at run start. A long depth run therefore drifts
+  arbitrarily far from main as siblings merge, and `research-lines.md` already
+  names the danger ("a stale line reverting others' wins").
+The kernel already reconciles a PR whose base moves AFTER it opens: an open PR
+keeps its run in the in-review state, and the tick's follow-up conflict wake
+(`followup.py`) fetches the moved base into the workspace and asks the agent to
+merge and re-measure. So the only real gap is the first bullet — a line that
+never re-syncs main mid-run and opens its PR against a base superseded days
+earlier.
+
+## Proposed protocol
+
+1. **Re-pin at each wake, not only at run start.** When a line wakes for its
+   next depth iteration, the kernel merges main into the line and hands the
+   agent a short digest of what changed since it last ran — the sibling record
+   moves and the files they touched. The agent decides what to re-run given
+   the new base. This bounds drift to a single iteration instead of the whole
+   run.
+
+2. **Never mid-experiment.** A running eval keeps its base. Re-pinning happens
+   only at the iteration boundary, the sleep-to-wake seam, so no in-flight
+   measurement is invalidated and no launch is wasted.
+
+3. **Re-measure the baseline at the new merge-base.** This is the roadmap's
+   "baseline re-run at merge-base." `research-lines.md` already makes every
+   claim name the baseline pair it was measured against, so a re-pinned line
+   stays legible about which base each number used.
+
+4. **Keep a PR reconcilable after the run's terminal.** A line whose PR is
+   open stays reachable until the PR is merged or closed, so a base that moves
+   after the PR opens fires the existing conflict wake — merge main,
+   re-measure, push — instead of stranding the PR for a human.
+
+## Decisions (owner, 2026-09-08)
+
+The semantic choices, settled — the mechanics follow from them.
+
+1. **Re-pin cadence: only when main moved.** Each wake does a cheap
+   fetch-and-compare; it re-merges and re-pins only when a sibling actually
+   landed something. No churn when nothing changed.
+2. **What the agent sees: the record move, plus each sibling PR's metric and a
+   one-line summary — not full diffs.** Enough to decide whether its line is
+   still worth pursuing, without flooding its context.
+3. **A superseded axis: tell, don't force.** The wake digest says its axis was
+   beaten (e.g. "warmdown was taken further by #10"); the agent decides to
+   pivot or push on. The kernel never kills a line for it.
+4. **Healing a PR after its base moves: already handled, no new mechanism.**
+   An open PR's run stays in-review, and the follow-up conflict wake already
+   fetches the moved base and asks the agent to merge and re-measure. The
+   note's earlier "post-terminal" framing was wrong (terra, #341): the run is
+   not terminated while its PR is open. Base reintegration is therefore stage 1
+   alone — closing the during-run drift; the post-open case needs nothing new.
+5. **Who pays the re-measure GPU: only when the agent keeps its change.** The
+   re-measure is then a normal launch against the line's own budget. No eager
+   baseline re-runs on every merge.
+
+**Build order.** The whole feature is one stage: re-pin at wake with the digest
+(decisions 1–3), the re-measure paid only on keep (decision 5). Decision 4 needs
+no code — the existing follow-up conflict wake already covers a base that moves
+after the PR opens.
+
+## Why this shape addresses the problem
+
+The base pin is correct during a run — you cannot measure improvement against
+a moving target. The failure is not the pin; it is holding one pin for a
+multi-day run and having no reconciliation once the run ends. Waking the line to merge the fresh base keeps the stability the pin gives
+while bounding the drift to a single iteration, and it reuses the exact
+mechanism the in-review conflict wake already uses — the kernel fetches, the
+agent merges — rather than adding new kernel git machinery. The post-open case
+needs nothing more: an open PR's run stays in-review and that same conflict
+wake already reconciles it.

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/docs/design/onboarding.md

@@ -15,7 +15,7 @@ honest when it says three steps:
 
 ## What the wizard does
 
-`python -m autoresearch.init` (interactive; every answer has a flag for
+`python -m outerloop.init` (interactive; every answer has a flag for
 non-interactive use):
 
 - **Detect compute.** `sbatch` on PATH → Slurm mode (prompt for account and
@@ -47,7 +47,7 @@ non-interactive use):
   The doctor is re-runnable on its own (`init --doctor`) and is the first
   thing support asks for.
 - **Print the start command.** Nothing starts implicitly. The command is
-  `autoresearch start` on both paths: it submits the resident tick where
+  `outerloop start` on both paths: it submits the resident tick where
   `sbatch` exists and runs the local loop elsewhere, taking the root and
   placement from flags, the environment, or the `.env` the wizard wrote.
 
@@ -73,7 +73,7 @@ simultaneously the zero-Slurm on-ramp and the paper's Karpathy-loop
 ablation cell (width 1 × serialized) — the same kernel, the compute seam
 swapped, nothing else different.
 
-- **The chain is a loop.** No sbatch → `autoresearch start` runs
+- **The chain is a loop.** No sbatch → `outerloop start` runs
   `tick --loop`, a tick every cadence in the foreground. State stays in records on
   disk, so killing and restarting the loop resumes exactly like the Slurm
   chain surviving a dead tick.
@@ -98,8 +98,8 @@ swapped, nothing else different.
    `OUTERLOOP_COMPUTE` selection at the two `SlurmCompute()` sites,
    `tick --loop`, local-mode wake-arming skip, per-mode required-env
    relaxation (no account/partition in local mode), and the one launch
-   command `autoresearch start` (`src/autoresearch/cli.py`). Done.
-2. **The wizard**: `autoresearch.init` — detection, prompts, `.env` writer,
+   command `outerloop start` (`src/outerloop/cli.py`). Done.
+2. **The wizard**: `outerloop.init` — detection, prompts, `.env` writer,
    doctor (PAT path first).
 3. **The manifest flow**: App mint + installation discovery inside the
    wizard.

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/docs/design/reviewer-infra.md

@@ -252,9 +252,9 @@ cron (weekly) or by hand. It fans out one read-only lens session per digest
 section (`maintain.MAINTENANCE_LENSES`, plus `general` for the whole
 checklist) over a checkout of the calling repository's default branch, merges
 the opinions with the same summarizer the wide review round uses, and posts
-ONE rolling issue ("Maintainer digest") whose body each scan replaces;
-earlier digests stay in the edit history, and a short comment per scan
-notifies watchers. The role is `roles.maintainer_spec`: the reviewer's tools
+ONE rolling issue (titled "Maintainer digest — <date>", the date of the digest
+it currently shows) whose body each scan replaces; earlier digests stay in the
+edit history, and a short comment per scan notifies watchers. The role is `roles.maintainer_spec`: the reviewer's tools
 and verdict shape (findings through the syscall tool, no scope), a larger
 budget because a tree is more to read than a diff. Items carry a section
 (`--category`), an effort and risk estimate, and a kind: `change` is

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/docs/design/role-cli.md

@@ -30,7 +30,7 @@ The invariants, proven on #132/#133 and non-negotiable everywhere:
    kernel-side (authoritative validators, PAT-out-of-session, scope, budgets).
    The tool is ergonomics and fast feedback; authority stays in the kernel.
 2. **Sandbox-side tools are standalone** (stdlib-only — the target repo has no
-   autoresearch), which duplicates a little advisory validation, pinned by
+   outerloop), which duplicates a little advisory validation, pinned by
    parity tests (`test_artifact_path_check_matches_the_kernel`).
    **Orchestrator-side roles** (reviewer/verifier/panel/planner/steward run on
    our own checkout, not a target sandbox) import the real validators — no

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/docs/install.md

@@ -105,8 +105,9 @@ always exits successfully so your PR stays green.
 
 The same reviewer, pointed at your whole repository once a week: dead code,
 duplicated logic, oversized modules, stale pins, slow tests, repeated work on
-the hot path, documentation drift. It writes one issue, "Maintainer digest",
-and replaces its body each scan. It changes no code and opens no work orders.
+the hot path, documentation drift. It writes one issue, titled "Maintainer
+digest — <date>" (the date of the digest it shows), and replaces its body each
+scan. It changes no code and opens no work orders.
 Add `.github/workflows/maintenance.yml` with the same secret as the reviewer:
 
 ```yaml
@@ -227,6 +228,21 @@ declares Contents, Issues and Pull requests read-write and Metadata read,
 nothing else. If the install step was cut short, run
 `outerloop init --force --github-app` to finish and re-check it.
 
+**If you are a member, not an owner, of the organization.** Creating an App
+*owned by the org* needs org-owner rights, so init falls back to creating one
+under your personal account — and a personal App does not install on an org
+repo by default. You do not need an org-owned App or a shared key:
+
+1. In the App's settings, make it **public** (a private App installs only on
+   its owner's account, which is why the org repo is not offered).
+2. Request its installation on your repo; an **org owner approves** the request.
+3. Run `outerloop init --force --github-app` to record the installation.
+
+Your key never leaves your machine. To let the lab own the App centrally later,
+transfer it to the org from the App's Advanced settings — the same key keeps
+working, so nothing has to be recreated. init prints these steps itself when it
+detects the personal-App fallback.
+
 **A fine-grained PAT — the fallback.** For an org that already runs a machine
 user, or one where you cannot create Apps: pick `pat` (or pass `--pat-file`).
 Mint the token on the machine user with these settings:
@@ -284,8 +300,10 @@ release tag at the next cadence (pre-releases included; the repo is public, so
 no credential is needed). `main` follows every merge and is meant for the
 kernel's own developers. Whatever moves the checkout, you or the policy, the
 environment is synced to the commit that is checked out, or the deploy rolls
-back to the last commit whose environment was installed. The local loop runs the installed package: upgrade it with
-`pip install -U outerloop-science` and start it again.
+back to the last commit whose environment was installed. The local loop runs
+the installed package, which has no such policy: run `outerloop upgrade` to move
+it to the newest release (add `--pre` to track pre-releases), then start it
+again. That is `pip install --upgrade outerloop-science` under one verb.
 
 Experiments run wherever your `compute` backend says. Slurm is the first
 backend; the interface is small (submit a job, poll for completion), so a CI
@@ -318,7 +336,14 @@ still read). A Codex author always runs contained, so it also needs the image
 cluster, evals run inside the Apptainer image at `OUTERLOOP_IMAGE` (default
 `~/outerloop-images/agent-py312.sif`) in a jail that binds only the
 checked-out tree — an eval that needs data must fetch it into the tree, and
-GPU jobs are requested per node (`--gpus-per-node`).
+GPU jobs are requested per node (`--gpus-per-node`). The tick has three
+scheduling knobs. `OUTERLOOP_CADENCE_MIN`, read from the `.env`, is how often the
+chain ticks (minutes; default 30). Two finer ones are read from the tick's own
+environment (set at launch, not the per-tick `.env`): `OUTERLOOP_MIN_TICK_MINUTES`
+coalesces ticks that land too close together (0 disables; unset defaults to the
+lesser of 10 minutes and half the cadence), and `OUTERLOOP_MAX_JOB_MINUTES` caps
+the walltime the tick requests for the climb and author-sleep wake jobs it sizes
+(clamped under a code ceiling).
 
 **Local mode without an image.** On a machine with no Apptainer image,
 `OUTERLOOP_COMPUTE=local` still runs. Sessions run under the harness's own

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/docs/validation/author-syscalls.md

@@ -22,7 +22,7 @@ Then run one climb by hand (not via the tick):
 
 ```bash
 source env.sh
-uv run python -m autoresearch.attempt \
+uv run python -m outerloop.attempt \
   --target <org/repo> --benchmark <a-cheap-benchmark> \
   --run-root <run-root> --image <image.sif> \
   <the account/partition/limit args the tick normally passes>

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/pyproject.toml

@@ -11,6 +11,13 @@ license = "Apache-2.0"
 license-files = ["LICENSE", "NOTICE"]
 requires-python = ">=3.12"
 authors = [{ name = "Agentic Learning AI Lab, New York University" }]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
 dependencies = [
     "cryptography>=42",  # GitHub App auth (RS256 JWTs), the recommended identity
     "pydantic>=2",

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/src/outerloop/__init__.py

@@ -2,7 +2,7 @@
 
 import os
 
-__version__ = "0.1.0.dev3"
+__version__ = "0.1.1"
 
 
 def _bridge_legacy_env() -> None:

{outerloop_science-0.1.0.dev3 → outerloop_science-0.1.1}/src/outerloop/appauth.py

@@ -17,8 +17,10 @@ network; the production signer lives behind the `app-auth` extra.
 
 from __future__ import annotations
 
+import argparse
 import base64
 import json
+import os
 import time
 import urllib.error
 import urllib.parse
@@ -29,6 +31,7 @@ from pathlib import Path
 from typing import Any
 
 from outerloop.github import AUTH_SAFE_OPENER, FileTokenProvider, TokenProvider
+from outerloop.paths import CONFIG_DIR
 
 # RS256-sign the JWT signing input, returning the raw signature bytes.
 Signer = Callable[[bytes], bytes]
@@ -211,3 +214,17 @@ def resolve_bot_auth(pat_file: str | Path, app_file: str | Path = "") -> TokenPr
     if str(app_file).strip():
         return app_provider_from_file(Path(str(app_file)).expanduser())
     return FileTokenProvider(Path(str(pat_file)).expanduser())
+
+
+def add_credential_args(parser: argparse.ArgumentParser) -> None:
+    """Add the shared bot-auth options to a role parser: `--pat-file`, and
+    `--github-app-file`, which supplies installation tokens instead of the PAT
+    when set. `resolve_bot_auth` reads the pair. One owner so the defaults and
+    help cannot drift between attempt, followup, and steward."""
+    parser.add_argument("--pat-file", default=str(CONFIG_DIR / "bot_pat"))
+    parser.add_argument(
+        "--github-app-file",
+        default=os.environ.get("OUTERLOOP_GITHUB_APP_FILE", ""),
+        help="GitHub App config (JSON: app_id, installation_id, private_key); "
+        "when set, installation tokens replace the PAT",
+    )