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

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev1}/.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.dev1}/CHANGELOG.md

@@ -6,6 +6,44 @@ 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.
+
+### 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).
+
 ### Changed
 
 - The syscall channel dir in a workspace is now `.outerloop/` (the tool, the
@@ -51,6 +89,42 @@ 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.

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev1}/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.dev1/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.dev1}/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.dev1
+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
@@ -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.dev1}/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.dev0 → outerloop_science-0.1.0.dev1}/docs/design/dispatcher.md

@@ -236,7 +236,8 @@ 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
 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

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev1}/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.dev1}/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.dev1}/docs/install.md

@@ -14,7 +14,7 @@ minutes and needs no bot account, no cluster, and no GPU. Do that first.
 An automated reviewer comments on your pull requests. It never approves, never
 blocks a merge, and never fails your build.
 
-**You need:** an Anthropic API key. That's it.
+**You need:** an API key for the reviewer's model. Anthropic by default; the OpenAI and OpenRouter variants are below. That's it.
 
 **Step 1 — add the key as a repository secret.** Repo → Settings → Secrets and
 variables → Actions → New repository secret. Name it `ANTHROPIC_REVIEWER_KEY`.
@@ -187,7 +187,7 @@ add it to a team — teams grant more than it needs and inherit future grants.
 The quickest path is the guided setup:
 
 ```bash
-outerloop init      # asks for compute, target repo, placement, and auth
+outerloop init      # asks for compute, target repo, placement, auth, and the author's model key
 outerloop start
 ```
 
@@ -226,13 +226,26 @@ comma-separated partition list lets Slurm start each job wherever it fits
 first; `OUTERLOOP_PANEL` names the verify/review lenses (with
 `OUTERLOOP_PANEL_*_KEY_FILE` for their keys); the author backend is
 `OUTERLOOP_AUTHOR_BACKEND`/`OUTERLOOP_AUTHOR_MODEL`, its key file
-`OUTERLOOP_HARNESS_KEY_FILE` (Claude) or `OUTERLOOP_CODEX_KEY_FILE`
-(Codex). Evals run inside the
-Apptainer image at `OUTERLOOP_IMAGE` (default
+`OUTERLOOP_<BACKEND>_KEY_FILE` (`OUTERLOOP_CLAUDE_KEY_FILE`,
+`OUTERLOOP_CODEX_KEY_FILE`; `init` writes the key to
+`~/.config/outerloop/<backend>_key`, 0600, and a pre-rename `harness_key` is
+still read). A Codex author always runs contained, so it also needs the image
+(`OUTERLOOP_IMAGE`) and a Codex model in `OUTERLOOP_AUTHOR_MODEL`. On a
+cluster, evals run inside the Apptainer image at `OUTERLOOP_IMAGE` (default
 `~/autoresearch-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`).
 
+**Local mode without an image.** On a machine with no Apptainer image,
+`OUTERLOOP_COMPUTE=local` still runs. Sessions run under the harness's own
+sandbox, evaluations run bare in a throwaway tree under an allowlisted
+environment, both on your machine with your keys, and the loop says so once
+at start. The verification panel is off in this mode unless you set
+`OUTERLOOP_PANEL_UNCONTAINED=1`, because an uncontained judge holds a shell
+next to its own key file; a pull request opened without a panel says so. A
+Codex author needs the image in every mode. Contained local mode, the
+default on Linux once the image is published, needs Apptainer and the image.
+
 ---
 
 ## Billing Claude sessions to GCP credits (Vertex AI)

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev1}/docs/roadmap.md

@@ -100,6 +100,9 @@ standing instruction they supersede — a resumed agent honors stale constraints
 
 ## Phase 5 — Benchmark-climb pilot
 
+Retired 2026-09-06: the fleet has climbed gpt-speedrun since 2026-08-31 and the
+pilot repo is archived. Kept for the record.
+
 Target: [autoresearch-pilot](https://github.com/agentic-learning-ai-lab/autoresearch-pilot)
 — a non-research-bearing proving ground (tsp / denoise / speedup; deterministic,
 CPU-only, contract and baselines already committed). Decouples this roadmap from

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "outerloop-science"
 dynamic = ["version"]
-description = "Autonomous research agent that co-develops the lab's benchmark-bearing repos"
+description = "Autonomous research agents that improve the benchmark you point them at, one verified pull request at a time"
 readme = "README.md"
 license = "Apache-2.0"
 license-files = ["LICENSE", "NOTICE"]
@@ -35,6 +35,8 @@ dev = [
     "mypy>=1.13",
     "pytest>=8",
     "pre-commit>=4",
+    "pytest-xdist>=3",
+    "pytest-testmon>=2",
 ]
 
 [project.urls]
@@ -68,11 +70,15 @@ warn_unused_ignores = true
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-addopts = "-ra --strict-markers -m 'not slow and not llm and not slurm'"
+# parallel by default; tests/conftest.py applies the tiers (slow/llm/slurm off,
+# serial off while distributing). `-n0` runs serially, `--testmon` runs only
+# the tests affected by your edits.
+addopts = "-ra --strict-markers -n auto"
 markers = [
     "slow: long-running; nightly/manual only",
     "llm: calls a paid LLM API; manual only, never CI",
     "slurm: needs a Slurm cluster; manual only, never CI",
+    "serial: inspects the process table; runs alone via `pytest -n0 -m serial`",
 ]
 
 [tool.hatch.build.targets.sdist]

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev1}/scripts/tick_deploy.sh

@@ -96,7 +96,7 @@ if [ -r "$ENV_FILE" ]; then
     if [ "$owner" = "$(id -u)" ] && [ $((8#$perms & 8#022)) -eq 0 ]; then
         for _k in AUTORESEARCH_AUTHOR_BACKEND AUTORESEARCH_AUTHOR_MODEL \
                   AUTORESEARCH_CODEX_BIN AUTORESEARCH_CODEX_KEY_FILE \
-                  AUTORESEARCH_HARNESS_KEY_FILE \
+                  AUTORESEARCH_CLAUDE_KEY_FILE AUTORESEARCH_HARNESS_KEY_FILE \
                   AUTORESEARCH_VERTEX_PROJECT AUTORESEARCH_VERTEX_REGION \
                   AUTORESEARCH_VERTEX_ADC \
                   AUTORESEARCH_TARGET \

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev1}/src/outerloop/__init__.py

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

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev1}/src/outerloop/appmanifest.py

@@ -25,12 +25,14 @@ import os
 import secrets
 import time
 import urllib.error
+import urllib.parse
 import urllib.request
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
 from outerloop.appauth import API, build_app_jwt, signer_from_private_key
+from outerloop.paths import write_private
 
 # The hosted helper page: it auto-POSTs the manifest to GitHub, then displays the
 # returned code. It is also the manifest's redirect_url, so GitHub sends the code
@@ -90,10 +92,15 @@ def request_manifest_code(
     state = secrets.token_urlsafe(16)
     manifest = build_manifest(name, homepage_url)
     url = build_setup_url(manifest, state, org)
-    print_fn("Create your GitHub App — open this URL in a browser (any machine):")
+    where = f"the {org} organization" if org else "your account"
+    print_fn("Step 1 of 3: create the GitHub App.")
+    print_fn("  Open this link in a browser where you are signed in to GitHub (any machine):")
     print_fn(f"\n  {url}\n")
-    print_fn("Click 'Create GitHub App', then copy the code the page shows.")
-    return input_fn("Paste the code here: ").strip()
+    print_fn(f"  GitHub shows a page titled 'Create GitHub App' under {where}. Click the")
+    host = urllib.parse.urlsplit(SETUP_URL).netloc or SETUP_URL
+    print_fn("  green 'Create GitHub App' button. GitHub then sends you to")
+    print_fn(f"  {host}, which shows a one-time code.")
+    return input_fn("Paste that code here: ").strip()
 
 
 def _default_transport(request: urllib.request.Request) -> Any:
@@ -136,10 +143,10 @@ def save_app_creds(
     config_dir.mkdir(parents=True, exist_ok=True)
     slug = str(conversion["slug"])
     pem_path = config_dir / f"{slug}-app.pem"
-    pem_path.write_text(str(conversion["pem"]))
-    pem_path.chmod(0o600)
+    write_private(pem_path, str(conversion["pem"]))
     app_json = config_dir / f"github_app.{slug}.json"
-    app_json.write_text(
+    write_private(
+        app_json,
         json.dumps(
             {
                 "app_id": int(conversion["id"]),
@@ -148,9 +155,8 @@ def save_app_creds(
             },
             indent=2,
         )
-        + "\n"
+        + "\n",
     )
-    app_json.chmod(0o600)
     return pem_path, app_json
 
 
@@ -194,5 +200,4 @@ def set_installation_id(app_json: Path, installation_id: int) -> None:
     """Fill the installation id into an already-written github_app.<slug>.json."""
     data = json.loads(app_json.read_text())
     data["installation_id"] = int(installation_id)
-    app_json.write_text(json.dumps(data, indent=2) + "\n")
-    app_json.chmod(0o600)
+    write_private(app_json, json.dumps(data, indent=2) + "\n")

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev1}/src/outerloop/attempt.py

@@ -97,8 +97,11 @@ log = logging.getLogger(__name__)
 # tick preflights the panel key (and compares it against the author key —
 # role separation) before claiming/submitting.
 PANEL_KEY_DEFAULT = str(CONFIG_DIR / "verifier_key")
-HARNESS_KEY_DEFAULT = str(CONFIG_DIR / "harness_key")  # the claude author key
-CODEX_KEY_DEFAULT = str(CONFIG_DIR / "codex_key")  # the codex author key
+# One rule for author keys: ~/.config/outerloop/<backend>_key. `harness_key` is
+# the pre-rename name of the claude key; it is still read, never written.
+CLAUDE_KEY_DEFAULT = str(CONFIG_DIR / "claude_key")
+HARNESS_KEY_DEFAULT = str(CONFIG_DIR / "harness_key")  # legacy claude key
+CODEX_KEY_DEFAULT = str(CONFIG_DIR / "codex_key")
 
 
 def resolve_author_key_file(backend: str, explicit: str = "") -> str:
@@ -106,14 +109,27 @@ def resolve_author_key_file(backend: str, explicit: str = "") -> str:
     codex's both on disk), selected by backend — so the author backend is a
     config choice, not a key swap, and an in-flight run of either backend can
     still be woken/serviced after a fleet flip. An explicit path always wins;
-    otherwise the per-backend env var, then the packaged default path. The result
-    is always ~-expanded, so every caller gets a real path (an env value like
-    "~/.config/..." must not reach the token provider verbatim)."""
+    otherwise the per-backend env var, then the default path. For claude the
+    legacy spellings (`AUTORESEARCH_HARNESS_KEY_FILE`, `harness_key`) are still
+    honored, so a machine set up before the rename keeps working; the new name
+    wins when both exist. The result is always ~-expanded, so every caller gets
+    a real path (an env value like "~/.config/..." must not reach the token
+    provider verbatim)."""
     if not explicit:
         if backend == "codex":
             explicit = os.environ.get("AUTORESEARCH_CODEX_KEY_FILE") or CODEX_KEY_DEFAULT
         else:
-            explicit = os.environ.get("AUTORESEARCH_HARNESS_KEY_FILE") or HARNESS_KEY_DEFAULT
+            explicit = (
+                os.environ.get("AUTORESEARCH_CLAUDE_KEY_FILE")
+                or os.environ.get("AUTORESEARCH_HARNESS_KEY_FILE")
+                or ""
+            )
+            if not explicit:
+                explicit = CLAUDE_KEY_DEFAULT
+                if not os.path.exists(os.path.expanduser(explicit)) and os.path.exists(
+                    os.path.expanduser(HARNESS_KEY_DEFAULT)
+                ):
+                    explicit = HARNESS_KEY_DEFAULT
     return os.path.expanduser(explicit)
 
 
@@ -2179,6 +2195,12 @@ def _panel_lenses_from_args(args: Any) -> tuple[tuple[PanelLens, ...], tuple[str
         else:
             lens_key = panel_key
         try:
+            if not args.image:
+                log.warning(
+                    "panel lens %s runs uncontained (local mode, no image): the judge "
+                    "shares this machine with the operator's keys",
+                    backend,
+                )
             judge = build_harness(
                 lens_key,
                 reviewer_spec(),
@@ -3211,7 +3233,7 @@ def main() -> int:
         "--key-file",
         default="",
         help="author key file; default resolves per backend (config-driven): "
-        "AUTORESEARCH_HARNESS_KEY_FILE for claude, AUTORESEARCH_CODEX_KEY_FILE for codex",
+        "AUTORESEARCH_CLAUDE_KEY_FILE for claude, AUTORESEARCH_CODEX_KEY_FILE for codex",
     )
     parser.add_argument("--issue", type=int, default=0)
     parser.add_argument(

{outerloop_science-0.1.0.dev0 → outerloop_science-0.1.0.dev1}/src/outerloop/cli.py

@@ -46,6 +46,7 @@ TICK_ENV_KEYS = (
     "AUTORESEARCH_AUTHOR_MODEL",
     "AUTORESEARCH_CODEX_BIN",
     "AUTORESEARCH_CODEX_KEY_FILE",
+    "AUTORESEARCH_CLAUDE_KEY_FILE",
     "AUTORESEARCH_HARNESS_KEY_FILE",
     "AUTORESEARCH_VERTEX_PROJECT",
     "AUTORESEARCH_VERTEX_REGION",
@@ -165,19 +166,23 @@ def _setting(key: str, flag: str, environ: dict[str, str], from_file: dict[str,
     return from_file.get(key, "")
 
 
-def _home(environ: dict[str, str], cwd: Path) -> Path:
-    """The checkout the loop runs from: AUTORESEARCH_HOME, else the current
-    directory when it is one. Both modes need it; the tick's launch lanes
-    and GitHub servicing switch off without it."""
-    home = (
-        Path(environ["AUTORESEARCH_HOME"]).expanduser() if environ.get("AUTORESEARCH_HOME") else cwd
+def _home(environ: dict[str, str], cwd: Path, *, local: bool, root: Path) -> Path:
+    """The directory the loop runs from. On Slurm it must be a source
+    checkout (AUTORESEARCH_HOME, else the current directory): the chain
+    deploys from it and every job runs from a flight snapshot of its HEAD.
+    The local loop has no deploy step and runs the installed package, so it
+    uses a checkout when one is at hand and otherwise a `home` directory
+    under the state root, where flights and logs land."""
+    named = environ.get("OUTERLOOP_HOME") or environ.get("AUTORESEARCH_HOME")
+    home = Path(named).expanduser() if named else cwd
+    if (home / "scripts" / "tick_chain.sbatch").is_file():
+        return home
+    if local and not named:
+        return root / "home"
+    raise StartError(
+        f"{home} is not a source checkout (no scripts/tick_chain.sbatch); "
+        "run start from a clone of the kernel, or set OUTERLOOP_HOME to one"
     )
-    if not (home / "scripts" / "tick_chain.sbatch").is_file():
-        raise StartError(
-            f"{home} is not an autoresearch checkout (no scripts/tick_chain.sbatch); "
-            "run start from the checkout the chain should deploy from, or set AUTORESEARCH_HOME"
-        )
-    return home
 
 
 def plan_start(
@@ -207,13 +212,15 @@ def plan_start(
                 f"AUTORESEARCH_CADENCE_MIN must be a positive number of minutes, got {cadence!r}"
             )
     pat = _setting("AUTORESEARCH_PAT_FILE", "", environ, from_file)
-    # both modes run from a checkout: the tick's launch lanes and GitHub
-    # servicing switch off without AUTORESEARCH_HOME
-    home = _home(environ, cwd)
+    # Slurm runs from a checkout; the local loop runs the installed package
+    # and needs only a directory (the launch lanes and GitHub servicing
+    # switch off without AUTORESEARCH_HOME, so one is always set)
+    local_root = Path(root_s).expanduser() if root_s else DEFAULT_LOCAL_ROOT
+    home = _home(environ, cwd, local=(mode == "local"), root=local_root)
     if mode == "local":
         return StartPlan(
             mode="local",
-            root=Path(root_s).expanduser() if root_s else DEFAULT_LOCAL_ROOT,
+            root=local_root,
             home=home,
             cadence_min=cadence,
             pat_file=pat,
@@ -333,6 +340,7 @@ def start(args: argparse.Namespace) -> int:
         env["AUTORESEARCH_COMPUTE"] = "local"
         env["AUTORESEARCH_ROOT"] = str(plan.root)
         env["AUTORESEARCH_HOME"] = str(plan.home)
+        plan.home.mkdir(parents=True, exist_ok=True)  # <root>/home when there is no checkout
         if plan.cadence_min:
             env["AUTORESEARCH_CADENCE_MIN"] = plan.cadence_min
         if plan.pat_file: