outerloop-science 0.1.0.dev0__py3-none-any.whl → 0.1.0.dev2__py3-none-any.whl

outerloop/climbboard.py

@@ -391,6 +391,22 @@ def render_html(
         "border-radius:2px;display:inline-block;box-sizing:border-box}\n"
         ".pill{border-radius:.6rem;padding:.05rem .55rem;font-size:.72rem;\n"
         "font-weight:600;color:#fff}\n"
+        ".run.queue{width:100%;padding-bottom:.55rem}\n"
+        ".run.queue table{width:100%;border-collapse:collapse;margin-top:.35rem;\n"
+        "  font-size:.72rem;font-variant-numeric:tabular-nums}\n"
+        ".run.queue th{text-align:left;font-weight:500;color:var(--muted);\n"
+        "  padding:.1rem .6rem .2rem 0;border-bottom:1px solid var(--line)}\n"
+        ".run.queue td{padding:.17rem .6rem .17rem 0;border-bottom:1px solid var(--line);\n"
+        "  white-space:nowrap;vertical-align:middle;color:var(--ink)}\n"
+        ".run.queue tr:last-child td{border-bottom:0}\n"
+        ".run.queue .mono{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}\n"
+        ".run.queue td.name{max-width:24rem;overflow:hidden;text-overflow:ellipsis}\n"
+        ".run.queue td.part,.run.queue td.time{color:var(--muted)}\n"
+        ".run.queue .st{display:inline-block;min-width:1.5rem;text-align:center;\n"
+        "  border-radius:.4rem;padding:0 .35rem;font-size:.66rem;font-weight:600}\n"
+        ".run.queue .st-R{background:var(--win);color:#fff}\n"
+        ".run.queue .st-PD{background:var(--line);color:var(--muted)}\n"
+        ".run.queue .st-X{background:var(--near);color:#fff}\n"
         ".card{background:var(--card);border:1px solid var(--line);border-radius:.5rem;\n"
         "padding:1rem}\n"
         ".card label{font-size:.8rem;color:var(--muted);margin-right:1rem}\n"
@@ -773,6 +789,55 @@ def render_html(
         "    now.append(card);\n"
         "  }\n"
         "  if (!strip.runs.length) now.textContent = 'no active runs';\n"
+        "  // the kernel's own Slurm jobs, as squeue would list them (when\n"
+        "  // published): one full-width card in the strip, running jobs first\n"
+        "  if (Array.isArray(strip.queue) && strip.queue.length) {\n"
+        "    const ST = {RUNNING: 'R', PENDING: 'PD', COMPLETING: 'CG', CONFIGURING: 'CF'};\n"
+        "    // squeue's reading order: running, finishing, starting, waiting, other\n"
+        "    const RANK = {RUNNING: 0, COMPLETING: 1, CONFIGURING: 2, PENDING: 3};\n"
+        "    const rank = j => RANK[j.state] ?? 4;\n"
+        "    const jobs = [...strip.queue].sort((a, b) =>\n"
+        "      rank(a) - rank(b) || String(a.id).localeCompare(String(b.id)));\n"
+        "    const card = document.createElement('span'); card.className = 'run queue';\n"
+        "    const top = document.createElement('span'); top.className = 'top';\n"
+        "    const who = document.createElement('b'); who.textContent = 'squeue';\n"
+        "    const meta = document.createElement('span');\n"
+        "    const running = jobs.filter(j => j.state === 'RUNNING').length;\n"
+        "    meta.textContent = jobs.length + ' jobs · ' + running + ' running';\n"
+        '    meta.title = "the kernel\'s own Slurm jobs, as squeue --me lists them";\n'
+        "    top.append(who, meta); card.append(top);\n"
+        "    const table = document.createElement('table');\n"
+        "    const thead = table.createTHead().insertRow();\n"
+        "    for (const h of ['JOBID', 'NAME', 'ST', 'TIME', 'PARTITION', 'AGENT']) {\n"
+        "      const th = document.createElement('th'); th.textContent = h; thead.append(th);\n"
+        "    }\n"
+        "    const body = table.createTBody();\n"
+        "    const td = (tr, text, cls) => {\n"
+        "      const c = tr.insertCell(); c.textContent = text ?? '';\n"
+        "      if (cls) c.className = cls; return c;\n"
+        "    };\n"
+        "    for (const j of jobs) {\n"
+        "      const tr = body.insertRow();\n"
+        "      td(tr, j.id, 'mono');\n"
+        "      td(tr, j.name, 'mono name').title = j.name;\n"
+        "      const st = document.createElement('span');\n"
+        "      const code = ST[j.state] || j.state;\n"
+        "      st.className = 'st st-' + (code === 'R' || code === 'PD' ? code : 'X');\n"
+        "      st.textContent = code; st.title = j.state;\n"
+        "      tr.insertCell().append(st);\n"
+        "      td(tr, j.elapsed, 'mono time');\n"
+        "      // a job eligible for several partitions lists them comma-joined;\n"
+        "      // show the first and count the rest, full list on hover\n"
+        "      const parts = String(j.partition || '').split(',').filter(Boolean);\n"
+        "      const pc = td(tr, parts.length > 1 ? parts[0] + ' +' + (parts.length - 1)\n"
+        "        : parts[0] || '', 'part');\n"
+        "      pc.title = parts.join(', ');\n"
+        "      const a = td(tr, j.agent || '—', 'agent');\n"
+        "      if (j.agent) { a.style.color = agentColor(j.agent); a.style.fontWeight = '600'; }\n"
+        "    }\n"
+        "    card.append(table);\n"
+        "    now.append(card);\n"
+        "  }\n"
         "};\n"
         "refresh();\n"
         "// the strip re-FETCHES every few minutes (new/left/changed runs) and\n"
@@ -784,6 +849,110 @@ def render_html(
 
 
 STATUS_PATH = "climb/status.json"
+# The queue view shows the kernel's own jobs only. Fixed-name jobs (the tick
+# chain, issue sessions, climb sessions) are matched by shape; per-run jobs
+# (wake, followup, launch) are matched against the names the kernel itself
+# derives from this target's run ids, with the same 60-character cut Slurm
+# forces on them; an eval's name is a liveness hash and is claimed only
+# through its run's marker. Anything else on the account is the operator's
+# and never leaves the cluster.
+JOB_NAME_LIMIT = 60
+FIXED_JOB_PATTERNS = tuple(
+    re.compile(p)
+    for p in (
+        r"^(autoresearch|outerloop)-(resident|tick)$",
+        r"^climb-[\w.-]+-agent-\d+$",
+        r"^(steward|climb)-issue-\d+$",
+    )
+)
+_AGENT_RE = re.compile(r"agent-\d+")
+
+
+def is_fixed_kernel_job(name: str) -> bool:
+    return any(p.match(name) for p in FIXED_JOB_PATTERNS)
+
+
+def run_job_names(root: Path, target: str) -> dict[str, tuple[str, str, bool]]:
+    """Expected per-run job names for `target`: name -> (run_id, agent,
+    is_prefix). Exact for wake and followup; a prefix for launches, whose
+    names end in the experiment's own label. Every run of the target counts,
+    ended ones too: a finishing job can outlive its record's state."""
+    out: dict[str, tuple[str, str, bool]] = {}
+    for record in list_runs(root):
+        if record.target != target:
+            continue
+        rid, agent = record.run_id, record.agent_id
+        for name, prefix in (
+            (f"wake-{rid}", False),
+            (f"followup-{rid}", False),
+            (f"{rid}-launch-", True),
+        ):
+            key = name[:JOB_NAME_LIMIT]
+            if key in out and out[key][0] != rid:
+                # two runs whose names collide under the cut: the job is still
+                # the kernel's, but nobody can say whose, so it is claimed by none
+                out[key] = ("", "", prefix)
+            else:
+                out[key] = (rid, agent, prefix)
+    return out
+
+
+def eval_job_owners(root: Path, target: str) -> dict[str, tuple[str, str]]:
+    """Slurm job id -> (run_id, agent) for every eval a live run of `target`
+    has dispatched: the measurer leaves the id in eval-*/submitted. Eval job
+    names are liveness hashes with no agent in them, so this is how the queue
+    view knows whose eval is whose."""
+    out: dict[str, tuple[str, str]] = {}
+    for record in list_runs(root):
+        if record.target != target or record.state == ENDED:
+            continue
+        for submitted in run_dir(root, record.run_id).glob("eval-*/submitted"):
+            try:
+                job_id = submitted.read_text().strip()
+            except OSError:
+                continue
+            if job_id:
+                out[job_id] = (record.run_id, record.agent_id)
+    return out
+
+
+def queue_rows(root: Path, target: str, snapshot: list[dict[str, str]]) -> list[dict[str, str]]:
+    """The published queue: kernel jobs from a `Compute.queue_snapshot()`,
+    each attributed to an agent (by eval marker, else by the agent id every
+    other kernel job carries in its name)."""
+    owners = eval_job_owners(root, target)
+    expected = run_job_names(root, target)
+    rows: list[dict[str, str]] = []
+    for job in snapshot:
+        name = str(job.get("name", ""))
+        job_id = str(job.get("id", ""))
+        run_id = agent = ""
+        if job_id in owners:  # an eval of one of this target's live runs
+            run_id, agent = owners[job_id]
+        elif name in expected and not expected[name][2]:  # wake / followup, exact
+            run_id, agent = expected[name][:2]
+        elif any(name.startswith(k) for k, v in expected.items() if v[2]):  # a launch
+            run_id, agent = next(v[:2] for k, v in expected.items() if v[2] and name.startswith(k))
+        elif is_fixed_kernel_job(name):
+            found = _AGENT_RE.search(name)
+            agent = found.group(0) if found else ""
+        else:
+            continue  # an eval whose marker is not written yet, or the operator's own job
+        rows.append(
+            {
+                "id": str(job.get("id", "")),
+                "name": name,
+                "state": str(job.get("state", "")),
+                "elapsed": str(job.get("elapsed", "")),
+                "partition": str(job.get("partition", "")),
+                "submitted": str(job.get("submitted", "")),
+                "agent": agent,
+                "run_id": run_id,
+            }
+        )
+    return rows
+
+
 _LIVE_STATES = ("implementing", "waiting", "in-review", "concluding")
 
 
@@ -823,7 +992,13 @@ def _experiment_progress(root: Path, record: Any) -> tuple[int, int, int]:
     return (done, len(names), minutes)
 
 
-def collect_status(root: Path, target: str, now: float, contract: Any = None) -> dict[str, Any]:
+def collect_status(
+    root: Path,
+    target: str,
+    now: float,
+    contract: Any = None,
+    queue: list[dict[str, str]] | None = None,
+) -> dict[str, Any]:
     """The fleet's live picture for `target`: one entry per non-terminal run.
     Timestamps, not durations — the page computes elapsed time client-side,
     so the strip feels live between pushes."""
@@ -878,15 +1053,25 @@ def collect_status(root: Path, target: str, now: float, contract: Any = None) ->
             }
         )
     runs.sort(key=lambda r: str(r.get("run_id")))
-    return {"target": target, "published": now, "runs": runs}
+    status: dict[str, Any] = {"target": target, "published": now, "runs": runs}
+    if queue is not None:  # a snapshot was taken (Slurm); the local loop has no queue
+        status["queue"] = queue_rows(root, target, queue)
+    return status
 
 
-def service_status(root: Path, github: Any, target: str, now: float, contract: Any = None) -> bool:
+def service_status(
+    root: Path,
+    github: Any,
+    target: str,
+    now: float,
+    contract: Any = None,
+    queue: list[dict[str, str]] | None = None,
+) -> bool:
     """Publish the strip when the fleet's SHAPE changed — a run appearing,
     leaving, or changing state/phase — never on every tick: the page shows
     elapsed time client-side, so timestamp-only drift is not worth a commit.
     Advisory like the board; True when a write happened."""
-    status = collect_status(root, target, now, contract)
+    status = collect_status(root, target, now, contract, queue)
     try:
         existing_raw: str | None = github.get_file(target, STATUS_PATH, BOARD_BRANCH)
     except Exception as exc:
@@ -920,10 +1105,30 @@ def service_status(root: Path, github: Any, target: str, now: float, contract: A
                 "sleep_k",
             )
             shape = lambda runs: [{k: r.get(k) for k in keys} for r in runs]
+            # the queue's shape is which jobs exist, their state, partition and
+            # attribution (an eval claimed by its marker one tick later must
+            # republish); elapsed time drifts every tick and is left out
+            # an absent queue (no snapshot) and an empty one (nothing running)
+            # are different shapes: recovering from a blind tick must publish
+            qshape = lambda q: (
+                None
+                if q is None
+                else [
+                    (
+                        j.get("id"),
+                        j.get("state"),
+                        j.get("partition"),
+                        j.get("agent"),
+                        j.get("run_id"),
+                    )
+                    for j in q
+                ]
+            )
             if (
                 isinstance(existing, dict)
                 and isinstance(existing.get("runs"), list)
                 and shape(existing["runs"]) == shape(status["runs"])
+                and qshape(existing.get("queue")) == qshape(status.get("queue"))
             ):
                 return False
         except (ValueError, TypeError, AttributeError):

outerloop/compute.py

@@ -95,6 +95,10 @@ class JobSpec:
     # Slurm scheduling controls
     dependency: str = ""  # e.g. "afterany:12345" or "singleton"
     begin: str = ""  # e.g. "now+30" or an absolute "YYYY-MM-DDTHH:MM:SS"
+    # submitted held (PENDING, reason JobHeldUser) until `release`: the
+    # tick's launch admission lets GPU launches into the queue in order,
+    # under the per-user cap, instead of queueing them all at once
+    hold: bool = False
     extra: tuple[str, ...] = ()
 
     def to_argv(self) -> list[str]:
@@ -104,12 +108,13 @@ class JobSpec:
             "sbatch",
             "--parsable",
             f"--job-name={self.job_name}",
-            f"--account={self.account}",
             f"--time={self.time_minutes}",
             f"--cpus-per-task={self.cpus}",
             f"--mem={self.mem}",
             f"--output={self.output}",
         ]
+        if self.account:  # unset bills the caller's default Slurm association
+            argv.append(f"--account={self.account}")
         if self.partition:  # unset lets Slurm pick its default partition
             argv.append(f"--partition={self.partition}")
         if self.gpus:
@@ -120,6 +125,8 @@ class JobSpec:
             argv.append(f"--gpus-per-node={self.gpus}")
         if self.qos:
             argv.append(f"--qos={self.qos}")
+        if self.hold:
+            argv.append("--hold")
         if self.dependency:
             argv.append(f"--dependency={self.dependency}")
         if self.begin:
@@ -133,6 +140,11 @@ class JobSpec:
         return argv
 
 
+# `reason` and `gres` feed launch admission (why a job waits, how many GPUs it
+# asks for); the board reads the first six by key and ignores the rest
+QUEUE_FIELDS = ("id", "name", "state", "elapsed", "partition", "submitted", "reason", "gres")
+
+
 class Compute(Protocol):
     """The verbs every compute backend implements. Callers (the measurer, the
     launcher, the wake dispatcher) depend on this, never on a backend."""
@@ -142,17 +154,19 @@ class Compute(Protocol):
     def pending_reason(self, job_id: str) -> str: ...
     def job_partition(self, job_id: str) -> str: ...
     def active_job_names(self) -> list[str]: ...
+    def queue_snapshot(self) -> list[dict[str, str]]: ...
     def job_id_for_name(self, name: str) -> str: ...
     def cancel(self, job_id: str) -> None: ...
+    def release(self, job_id: str) -> None: ...
 
 
 def local_mode() -> bool:
-    """AUTORESEARCH_COMPUTE=local selects the monolith: every job a
+    """OUTERLOOP_COMPUTE=local selects the monolith: every job a
     synchronous subprocess of the caller (docs/design/onboarding.md) — the
     zero-cluster on-ramp and the paper's serialized-baseline ablation. Any
     other value (or none) is Slurm. This helper is the only reader of the
     env var, so mode checks cannot drift."""
-    return os.environ.get("AUTORESEARCH_COMPUTE", "").strip().lower() == "local"
+    return os.environ.get("OUTERLOOP_COMPUTE", "").strip().lower() == "local"
 
 
 def compute_from_env() -> SlurmCompute | LocalCompute:
@@ -257,6 +271,26 @@ class SlurmCompute:
             raise SlurmQueryError(f"squeue failed ({result.returncode}): {result.stderr.strip()}")
         return [line.strip() for line in result.stdout.splitlines() if line.strip()]
 
+    def queue_snapshot(self) -> list[dict[str, str]]:
+        """This user's PENDING and RUNNING jobs as rows of QUEUE_FIELDS — what
+        a queue view needs, nothing a caller acts on. Raises SlurmQueryError
+        on failure, like active_job_names."""
+        try:
+            result = self.runner(
+                ["squeue", "--me", "--noheader", "-o", "%i|%j|%T|%M|%P|%V|%r|%b"],
+                self.command_timeout_s,
+            )
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            raise SlurmQueryError(f"squeue did not run: {exc}") from exc
+        if result.returncode != 0:
+            raise SlurmQueryError(f"squeue failed ({result.returncode}): {result.stderr.strip()}")
+        rows: list[dict[str, str]] = []
+        for line in result.stdout.splitlines():
+            parts = line.strip().split("|")
+            if len(parts) == len(QUEUE_FIELDS) and parts[0]:
+                rows.append(dict(zip(QUEUE_FIELDS, parts, strict=True)))
+        return rows
+
     def job_id_for_name(self, name: str) -> str:
         """The id of this user's PENDING/RUNNING job with exactly `name`, or
         "" if none. Authoritative for "is this still live" independent of any
@@ -283,6 +317,15 @@ class SlurmCompute:
         if result.returncode != 0:
             log.warning("scancel %s: %s", job_id, result.stderr.strip())
 
+    def release(self, job_id: str) -> None:
+        """Release a job submitted with `hold` so the scheduler may start it.
+        Releasing a job that is not held is not an error."""
+        if not job_id.isdigit():
+            raise ValueError(f"not a job id: {job_id!r}")
+        result = self.runner(["scontrol", "release", job_id], self.command_timeout_s)
+        if result.returncode != 0:
+            log.warning("scontrol release %s: %s", job_id, result.stderr.strip())
+
 
 # Local job ids start far above any real Slurm id so the two can never be
 # confused in a record; they stay numeric because callers validate isdigit.
@@ -294,7 +337,7 @@ def _local_state_dir() -> Path | None:
     attempts it spawns each hold their own LocalCompute): under the state
     root when the deployment names one, else nowhere (memory-only — tests).
     Local jobs are synchronous, so only TERMINAL states ever need sharing."""
-    root = os.environ.get("AUTORESEARCH_ROOT", "").strip()
+    root = os.environ.get("OUTERLOOP_ROOT", "").strip()
     return Path(root) / "local_jobs" if root else None
 
 
@@ -330,7 +373,7 @@ class LocalCompute:
         # the submitting process holds live keys (and any inherited
         # APPTAINERENV_* would cross --cleanenv into the container), so the
         # job script starts from a minimal environment and sets its own.
-        # AUTORESEARCH_* / REVIEW_HERMES_* pass through as a PREFIX rule:
+        # OUTERLOOP_* / REVIEW_HERMES_* pass through as a PREFIX rule:
         # Slurm jobs inherit the tick's whole environment, and local jobs
         # need the same config surface (compute mode, author backend, panel,
         # key-file PATHS). Enumerating allowed names is how a mode flag dies
@@ -344,7 +387,7 @@ class LocalCompute:
             k: v
             for k, v in os.environ.items()
             if k in ("PATH", "HOME", "LANG", "TMPDIR", "SLURM_TMPDIR", "USER", "LOGNAME")
-            or (k.startswith(("AUTORESEARCH_", "REVIEW_HERMES_")) and not _secret_name(k))
+            or (k.startswith(("OUTERLOOP_", "REVIEW_HERMES_")) and not _secret_name(k))
         }
         try:
             # the job runs in its OWN session (= process group), so the
@@ -389,6 +432,13 @@ class LocalCompute:
                 tmp = state_dir / f".{job_id}.{os.getpid()}.tmp"
                 tmp.write_text(state)
                 os.replace(tmp, state_dir / job_id)
+                # the job's combined stdout/stderr beside its state: a failed local
+                # job otherwise leaves nothing to read (#295)
+                out_fd = os.open(
+                    state_dir / f"{job_id}.out", os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600
+                )
+                with os.fdopen(out_fd, "w") as fh:
+                    fh.write(output)
                 # opportunistic prune: one entry per job would leak forever
                 # on a long-running loop; anything the sweep could still want
                 # is far younger than a day
@@ -408,7 +458,12 @@ class LocalCompute:
             except OSError as exc:
                 log.warning("local job %s: output write failed: %s", spec.job_name, exc)
         self._states[job_id] = state
-        log.info("ran %s locally as job %s: %s", spec.job_name, job_id, state)
+        where = (
+            f"; output in {state_dir / (job_id + '.out')}"
+            if state_dir and state != "COMPLETED"
+            else ""
+        )
+        log.info("ran %s locally as job %s: %s%s", spec.job_name, job_id, state, where)
         return job_id
 
     def status(self, job_id: str) -> str:
@@ -436,6 +491,9 @@ class LocalCompute:
     def active_job_names(self) -> list[str]:
         return []  # synchronous: nothing is ever pending or running
 
+    def queue_snapshot(self) -> list[dict[str, str]]:
+        return []
+
     def job_id_for_name(self, name: str) -> str:
         return ""
 
@@ -444,6 +502,9 @@ class LocalCompute:
             raise ValueError(f"not a job id: {job_id!r}")
         # already terminal; cancelling a finished job is not an error
 
+    def release(self, job_id: str) -> None:
+        """Local jobs run synchronously at submit; nothing is ever held."""
+
 
 def parse_elapsed(text: str) -> int | None:
     """Seconds in a sacct Elapsed field: `MM:SS`, `HH:MM:SS` or `D-HH:MM:SS`.
@@ -477,6 +538,22 @@ def is_pending(state: str) -> bool:
     return state.startswith("PENDING")
 
 
+def gpus_in_gres(gres: str) -> int:
+    """GPUs a queue row asks for, from squeue's %b (`gres/gpu:8`,
+    `gres/gpu:h200:2`, `gres:gpu:4`; `N/A` or anything else = 0)."""
+    total = 0
+    for part in gres.replace(";", ",").split(","):
+        fields = part.strip().split(":")
+        if (len(fields) >= 2 and fields[0] in ("gres/gpu", "gpu")) or (
+            len(fields) >= 3 and fields[0] == "gres" and fields[1] == "gpu"
+        ):
+            try:
+                total += int(fields[-1])
+            except ValueError:
+                continue
+    return total
+
+
 def quote_command(parts: Sequence[str]) -> str:
     """Shell-quote a command for JobSpec.command (--wrap takes a string)."""
     return " ".join(shlex.quote(p) for p in parts)

outerloop/contract.py

@@ -26,6 +26,7 @@ SELF_REPO = "outerloop-science/outerloop"
 # `.autoresearch.yaml` (targets written before the rename) is still honored. Every
 # read goes through `find_contract`, which tries the new name first. Neither is
 # ever a writable path for the agent.
+# The pre-rename name is dropped in the release after 0.1.
 CONTRACT_NAMES: tuple[str, ...] = (".outerloop.yaml", ".autoresearch.yaml")
 CONTRACT_NAME = CONTRACT_NAMES[0]  # what the docs and new contracts use
 ALWAYS_FORBIDDEN: tuple[str, ...] = (".github", *CONTRACT_NAMES)
@@ -126,8 +127,8 @@ class Benchmark(_StrictModel):
     eval_minutes: int | None = Field(default=None, ge=1)
     # GPUs for every dispatched job of this benchmark — gate measures and
     # author launches alike. 0 (default) = CPU. A GPU benchmark needs the
-    # deployment to name a GPU lane (AUTORESEARCH_GPU_PARTITION, optionally
-    # AUTORESEARCH_GPU_ACCOUNT); without one the tick refuses to launch
+    # deployment to name a GPU lane (OUTERLOOP_GPU_PARTITION, optionally
+    # OUTERLOOP_GPU_ACCOUNT); without one the tick refuses to launch
     # attempts on it rather than queue evals that can never run. Bounded at
     # one node's worth: multi-node evals are not a shape the jail supports.
     gpus: int = Field(default=0, ge=0, le=8)

outerloop/followup.py

@@ -37,7 +37,7 @@ from outerloop.github import (
     contract_at,
     is_own_login,
 )
-from outerloop.harness import Harness, outage, redact
+from outerloop.harness import Harness, default_binary, outage, redact
 from outerloop.markers import has_marker, marker
 from outerloop.orchestrator import (
     Evaluator,
@@ -958,6 +958,7 @@ def _respond(
                         changed=changed,
                         conflict_head=conflict_head if conflict_wake else "",
                         base_synced=base_synced,
+                        pr_head=str((pr.get("head") or {}).get("sha", "")),
                         panel_wake=panel_wake,
                         now=now,
                         secrets=secrets,
@@ -1593,6 +1594,7 @@ def _park_remeasure(
     changed: list[str],
     conflict_head: str,
     base_synced: bool,
+    pr_head: str,
     panel_wake: bool,
     now: float,
     secrets: tuple[str, ...],
@@ -1606,6 +1608,11 @@ def _park_remeasure(
         "candidate_sha": snap.commit,
         "candidate_ref": snap.ref,
         "parent": ws.git("rev-parse", "HEAD").strip(),
+        # the PR's head on GitHub at park. After a base sync `parent` is the
+        # session's local merge, which GitHub never saw: the resume compares
+        # the live head against THIS, not against parent (speedrun agent-03,
+        # 2026-09-06: every base-synced re-measure was abandoned as "moved")
+        "pr_head": pr_head,
         "job_ids": list(pend.job_ids),
         "afterany": pend.afterany(),
         "seed": run_seed,
@@ -1729,7 +1736,13 @@ def _resume_measure(
             ws.git("clean", "-fdq")
         drop_snapshot(ws, snapshot)
         github.comment(record.target, number, f"{REPLY_MARKER}\n{note}")
-        save_record(run_root, replace(load_record(run_root, run_id), followup_stage={}), now)
+        # the thread was told and invited to ask again: that next ask needs a
+        # follow-up, so the landed measure counts as progress for the cap
+        save_record(
+            run_root,
+            replace(load_record(run_root, run_id), followup_stage={}, wake_attempts=0),
+            now,
+        )
         return FollowupOutcome(run_id, "replied", "dispatched re-measure abandoned")
 
     try:
@@ -1764,12 +1777,16 @@ def _resume_measure(
             )
         return FollowupOutcome(run_id, "replied", "dispatched re-measure already landed")
 
-    # the sealed commit is parented on the head the PR had at park: a push
-    # since (a maintainer's) makes it unpushable AND measured on a tree that
-    # is no longer the PR's — abandon honestly rather than force or rebuild
-    if head_now and parent and head_now != parent:
+    # the sealed commit descends from the head the PR had at park (directly,
+    # or through the session's local base-sync merge): a push since (a
+    # maintainer's) makes it unpushable AND measured on a tree that is no
+    # longer the PR's — abandon honestly rather than force or rebuild. Stages
+    # parked before `pr_head` was recorded fall back to conflict_head, then
+    # parent.
+    parked_head = str(stage.get("pr_head") or stage.get("conflict_head") or parent)
+    if head_now and parked_head and head_now != parked_head:
         return _abandon(
-            f"_(The PR's head moved while the re-measure ran (`{parent[:12]}` → "
+            f"_(The PR's head moved while the re-measure ran (`{parked_head[:12]}` → "
             f"`{head_now[:12]}`), so the measured change no longer applies to this "
             "branch and was not pushed. Ask again and it will be redone on the new head.)_"
         )
@@ -1946,16 +1963,14 @@ def main() -> int:
     parser.add_argument("--run-id", required=True)
     parser.add_argument("--image", default="")
     parser.add_argument("--uncontained", action="store_true")
-    parser.add_argument("--claude-bin", default=os.path.expanduser("~/.local/bin/claude"))
+    parser.add_argument("--claude-bin", default=default_binary("claude"))
     parser.add_argument(
         "--codex-bin",
-        default=os.path.expanduser(
-            os.environ.get("AUTORESEARCH_CODEX_BIN") or "~/.local/bin/codex"
-        ),
+        default=default_binary("codex"),
     )
     parser.add_argument(
         "--model",
-        default=os.environ.get("AUTORESEARCH_AUTHOR_MODEL") or "claude-opus-5",
+        default=os.environ.get("OUTERLOOP_AUTHOR_MODEL") or "claude-opus-5",
         help="fallback model only; a run's OWN (backend, model) from its record wins",
     )
     # No --author-backend: a follow-up services ONE run, whose backend+model are
@@ -1981,7 +1996,7 @@ def main() -> int:
     parser.add_argument("--pat-file", default=str(CONFIG_DIR / "bot_pat"))
     parser.add_argument(
         "--github-app-file",
-        default=os.environ.get("AUTORESEARCH_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",
     )
@@ -1989,7 +2004,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",
+        "OUTERLOOP_CLAUDE_KEY_FILE for claude, OUTERLOOP_CODEX_KEY_FILE for codex",
     )
     parser.add_argument(
         "--panel",
@@ -1998,10 +2013,10 @@ def main() -> int:
         "re-read a pushed code change; '' = no re-read, a changed PR stays human-merged",
     )
     parser.add_argument("--panel-key-file", default="", help="the claude panel lenses' key file")
-    parser.add_argument("--account", default=os.environ.get("AUTORESEARCH_ACCOUNT", ""))
-    parser.add_argument("--partition", default=os.environ.get("AUTORESEARCH_PARTITION", ""))
-    parser.add_argument("--gpu-partition", default=os.environ.get("AUTORESEARCH_GPU_PARTITION", ""))
-    parser.add_argument("--gpu-account", default=os.environ.get("AUTORESEARCH_GPU_ACCOUNT", ""))
+    parser.add_argument("--account", default=os.environ.get("OUTERLOOP_ACCOUNT", ""))
+    parser.add_argument("--partition", default=os.environ.get("OUTERLOOP_PARTITION", ""))
+    parser.add_argument("--gpu-partition", default=os.environ.get("OUTERLOOP_GPU_PARTITION", ""))
+    parser.add_argument("--gpu-account", default=os.environ.get("OUTERLOOP_GPU_ACCOUNT", ""))
     parser.add_argument(
         "--panel-minutes",
         type=int,
@@ -2026,11 +2041,10 @@ def main() -> int:
     )
     from outerloop.panel import panel_read_minutes
 
-    # cluster coordinates (the climb's own resolver): a GPU benchmark's
-    # re-measure is dispatched to the GPU lane; with none, evals run inline
-    dispatch = (
-        _dispatch_settings(args) if (args.account or args.partition or args.gpu_partition) else None
-    )
+    # cluster coordinates (the climb's own resolver, the climb's own rule):
+    # a real image dispatches evals, a GPU benchmark's to the GPU lane; with
+    # no image, evals run inline. Account and partition are optional (#300).
+    dispatch = _dispatch_settings(args) if (args.image and Path(args.image).is_file()) else None
 
     # a follow-up services ONE run: reproduce THAT run's author (the persisted
     # (backend, model) PAIR), not the current fleet default, so a codex-authored

outerloop/github.py

@@ -43,21 +43,21 @@ DEFAULT_BOT_LOGIN = "agentic-learning-bot"
 def bot_login_from_env(default: str = DEFAULT_BOT_LOGIN) -> str:
     """The login the kernel posts and pushes as — the bot ACCOUNT under a PAT,
     the App's `<slug>[bot]` under App auth (docs/design/github-app-auth.md).
-    `AUTORESEARCH_BOT_LOGIN` sets it for every role at once (the tick exports
+    `OUTERLOOP_BOT_LOGIN` sets it for every role at once (the tick exports
     it, jobs inherit it); every own-comment filter, alarm-issue lookup and
     intake-claim scan keys on this string, so it must follow the credential."""
-    return os.environ.get("AUTORESEARCH_BOT_LOGIN", "").strip() or default
+    return os.environ.get("OUTERLOOP_BOT_LOGIN", "").strip() or default
 
 
 def bot_aliases_from_env() -> tuple[str, ...]:
     """Former logins the kernel posted as (comma-separated
-    `AUTORESEARCH_BOT_ALIASES`). Every issue, claim, alarm and PR created
+    `OUTERLOOP_BOT_ALIASES`). Every issue, claim, alarm and PR created
     before an identity flip carries the OLD login; recognition stays keyed on
     login — never on the public markers, which anyone can paste — so the set
     of our logins is what a flip must widen (live: after the App flip the
     intake lane claimed the kernel's own research-log issue, authored by the
     PAT account)."""
-    raw = os.environ.get("AUTORESEARCH_BOT_ALIASES", "")
+    raw = os.environ.get("OUTERLOOP_BOT_ALIASES", "")
     return tuple(dict.fromkeys(a.strip() for a in raw.split(",") if a.strip()))