outerloop-science 0.1.0.dev3__py3-none-any.whl → 0.1.0.dev4__py3-none-any.whl

outerloop/maintain.py

@@ -85,6 +85,17 @@ MAINTENANCE_LENSES: dict[str, str] = {
         "whose status no longer matches the code, knobs and flags the docs "
         "never name, wording that disagrees between two documents."
     ),
+    "architecture": (
+        "LENS — abstraction and extensibility, forward-looking rather than "
+        "cleanup: where two abstractions could be unified or a layer dropped "
+        "so the system is simpler to reason about; and, holding the principle "
+        "that a new backend, benchmark, or role should need zero kernel "
+        "change, where an extension point is missing so adding one today "
+        "forces a kernel edit. Name the files and propose the merge or the "
+        "seam; mark these decisions — a refactor of an abstraction many "
+        "parts of the system depend on is the maintainer's call, not a "
+        "mechanical change."
+    ),
 }
 
 SYSTEM_PROMPT = (
@@ -182,6 +193,14 @@ def _item(finding: Finding, repo: str, ref: str) -> str:
     return f"- {label}**{summary}.** {detail} ([{where}]({link}); {finding.confidence})"
 
 
+def digest_title(today: str) -> str:
+    """The rolling issue's title, carrying the date of the digest it shows so
+    its freshness reads from the issue list. A successful scan sets it to that
+    scan's date; a scan that could not run keeps the last good digest — and this
+    date — so a stalled scan reads as stale rather than falsely fresh."""
+    return f"{DIGEST_TITLE} — {today}"
+
+
 def render_digest(
     result: ReviewResult,
     *,
@@ -210,7 +229,16 @@ def render_digest(
         "",
     ]
     if result.notes:
-        lines += [result.notes, ""]
+        # keep the top a short summary (title, advisory, counts); the scan's
+        # own verdict and its rejected-findings reasoning fold away below it
+        lines += [
+            "<details><summary>Scan verdict and rejected findings</summary>",
+            "",
+            result.notes,
+            "",
+            "</details>",
+            "",
+        ]
     by_section: dict[str, list[Finding]] = {}
     for f in findings:
         section = f.category if f.category in MAINTENANCE_LENSES else "other"

outerloop/maintain_post_cli.py

@@ -18,7 +18,7 @@ from datetime import UTC, datetime
 from pathlib import Path
 
 from outerloop.github import EnvTokenProvider, GitHubClient
-from outerloop.maintain import DIGEST_TITLE, MARKER, render_digest, render_stub
+from outerloop.maintain import MARKER, digest_title, render_digest, render_stub
 from outerloop.posting import EXPECTED_FAILURES
 from outerloop.review import result_from_data
 
@@ -84,7 +84,7 @@ def post_digest(
                 str(envelope.get("detail", "")), repo=repo, ref=ref, today=today, who=who
             )
             if number is None:
-                client.create_issue(repo, DIGEST_TITLE, body)
+                client.create_issue(repo, digest_title(today), body)
             else:
                 client.comment(repo, number, body)
             return "skip-stub"
@@ -92,10 +92,10 @@ def post_digest(
         result = result_from_data(data if isinstance(data, dict) else {})
         body = render_digest(result, repo=repo, ref=ref, today=today, reviewed_by=who)
         if number is None:
-            number = client.create_issue(repo, DIGEST_TITLE, body)
+            number = client.create_issue(repo, digest_title(today), body)
             log.info("opened the digest issue %s#%s", repo, number)
             return "created"
-        client.update_issue(repo, number, body)
+        client.update_issue(repo, number, body, title=digest_title(today))
         # a body edit notifies nobody; the comment does
         client.comment(
             repo,

outerloop/review_summarize_cli.py

@@ -30,7 +30,7 @@ from outerloop.roles import summarizer_spec
 
 log = logging.getLogger(__name__)
 
-MAX_OPINIONS = 8  # artifacts are workflow-authored, but cap the read anyway
+MAX_OPINIONS = 12  # the maintenance scan fans out 9 lenses; cap the read, generously
 
 
 def _load_envelopes(root: Path, repo: str, number: int) -> list[dict]:

outerloop/steward.py

@@ -26,7 +26,7 @@ from dataclasses import replace as dc_replace
 from pathlib import Path
 from typing import Any, Protocol
 
-from outerloop.appauth import resolve_bot_auth
+from outerloop.appauth import add_credential_args, resolve_bot_auth
 from outerloop.attempt import (
     AttemptOutcome,
     Terminated,
@@ -750,7 +750,6 @@ def live_steward(
 def main() -> int:
     import argparse
     import base64
-    import os
     import time
     from datetime import UTC, datetime
 
@@ -774,13 +773,7 @@ def main() -> int:
     parser.add_argument("--session-minutes", type=int, default=60)
     parser.add_argument("--job-minutes", type=int, default=0)
     parser.add_argument("--deadline-margin-s", type=float, default=120.0)
-    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",
-    )
+    add_credential_args(parser)
     parser.add_argument(
         "--key-file",
         default=str(CONFIG_DIR / "steward_key"),

outerloop/tick.py

@@ -573,6 +573,7 @@ def service_in_review(
     dry_run: bool = False,
     allow_submit: bool = True,
     contract: Any = None,
+    records: list[RunRecord] | None = None,
 ) -> tuple[list[tuple[str, str]], list[tuple[str, str]]]:
     """PR-state transitions + follow-up job submission for in-review runs.
 
@@ -593,13 +594,15 @@ def service_in_review(
         panel_wake_pending,
     )
 
+    if records is None:
+        records = list_runs(root)
     ended: list[tuple[str, str]] = []
     submitted: list[tuple[str, str]] = []
-    for record in list_runs(root):
+    for record in records:
         if record.state != IN_REVIEW or not record.pr_url:
             continue
         try:
-            ending = close_if_done(root, record, github, now)
+            ending = close_if_done(root, load_record(root, record.run_id), github, now)
             if ending:
                 ended.append((record.run_id, ending))
                 continue
@@ -1268,7 +1271,13 @@ def _ledger_issue_cache(root: Path, target: str) -> Path:
     return root / ("research-log-issue-" + target.replace("/", "__"))
 
 
-def service_research_log(root: Path, github: Any, spec: FollowupSpec, now: float) -> int:
+def service_research_log(
+    root: Path,
+    github: Any,
+    spec: FollowupSpec,
+    now: float,
+    records: list[RunRecord] | None = None,
+) -> int:
     """STATE-driven ledger (terra #170 r1: wiring publisher calls at terminal
     sites missed four terminal paths — attempt error, zero-change resume,
     the direct live terminal, steward): any run of this target whose
@@ -1284,13 +1293,15 @@ def service_research_log(root: Path, github: Any, spec: FollowupSpec, now: float
     before the feature's first pass are marker-stamped silently (no
     backfill spam).
     """
+    if records is None:
+        records = list_runs(root)
     since_path = _ledger_since(root, spec.target)
     first_pass = not since_path.exists()
     if first_pass:
         with contextlib.suppress(OSError):
             since_path.write_text(str(now))
     published = 0
-    for record in list_runs(root):
+    for record in records:
         if record.target != spec.target or record.state not in (ENDED, IN_REVIEW):
             continue
         marker = _ledger_marker(root, record.run_id)
@@ -1603,139 +1614,138 @@ def _sweep_one(
     reaped: list[str],
     stuck: list[str],
 ) -> None:
-    if True:
-        # Leases first: a LIVE wake in flight owns this run — even the stuck
-        # verdict must wait for it (its session may be the one that succeeds).
-        lease = read_lease(root, record.run_id)
-        if lease is not None:
-            alive = _holder_alive(compute, lease.holder_job_id)
-            if not lease_is_stale(lease, now, lease_ttl_s, alive):
-                if not _armed_wake_lost(root, compute, record, lease, now, grace_s, dry_run):
-                    return
-                record = load_record(root, record.run_id)
-            if dry_run:
-                reaped.append(record.run_id)
+    # Leases first: a LIVE wake in flight owns this run — even the stuck
+    # verdict must wait for it (its session may be the one that succeeds).
+    lease = read_lease(root, record.run_id)
+    if lease is not None:
+        alive = _holder_alive(compute, lease.holder_job_id)
+        if not lease_is_stale(lease, now, lease_ttl_s, alive):
+            if not _armed_wake_lost(root, compute, record, lease, now, grace_s, dry_run):
                 return
-            if not reap_lease(root, record.run_id, reaper=f"{os.getpid()}-{now}", expected=lease):
-                return  # a concurrent tick reaped it first; it owns redelivery
+            record = load_record(root, record.run_id)
+        if dry_run:
             reaped.append(record.run_id)
-
-        # Layer 5: too many failed attempts is a terminal, reported state.
-        if record.wake_attempts >= MAX_WAKE_ATTEMPTS:
-            if not dry_run:
-                ended = replace(
-                    record,
-                    state=ENDED,
-                    ending=STUCK,
-                    ending_note=(
-                        f"{record.wake_attempts} wake attempts without the run leaving 'waiting'"
-                    ),
-                )
-                save_record(root, ended, now)
-            stuck.append(record.run_id)
             return
+        if not reap_lease(root, record.run_id, reaper=f"{os.getpid()}-{now}", expected=lease):
+            return  # a concurrent tick reaped it first; it owns redelivery
+        reaped.append(record.run_id)
+
+    # Layer 5: too many failed attempts is a terminal, reported state.
+    if record.wake_attempts >= MAX_WAKE_ATTEMPTS:
+        if not dry_run:
+            ended = replace(
+                record,
+                state=ENDED,
+                ending=STUCK,
+                ending_note=(
+                    f"{record.wake_attempts} wake attempts without the run leaving 'waiting'"
+                ),
+            )
+            save_record(root, ended, now)
+        stuck.append(record.run_id)
+        return
 
-        job_ids = _poll_targets(record)
-        if not job_ids:
-            # No job ids to poll. A BLIND PARK (the measurer could not read Slurm,
-            # so `MeasurementPending` carried no ids) still hibernated with a
-            # deadline — the deadline floor is its ONLY wake, so fire on it. A
-            # genuinely mid-write record has no deadline and is left alone.
-            # (A jobless CHECKPOINT SLEEP arrives here too — its deadline is
-            # near-term by construction, attempt.py sizes it to the next sweep
-            # pass, not the 12h queue slack that protects queued jobs.)
-            if record.deadline > 0 and now > record.deadline:
-                wake(record, "blind park past deadline", "deadline")
-            return
+    job_ids = _poll_targets(record)
+    if not job_ids:
+        # No job ids to poll. A BLIND PARK (the measurer could not read Slurm,
+        # so `MeasurementPending` carried no ids) still hibernated with a
+        # deadline — the deadline floor is its ONLY wake, so fire on it. A
+        # genuinely mid-write record has no deadline and is left alone.
+        # (A jobless CHECKPOINT SLEEP arrives here too — its deadline is
+        # near-term by construction, attempt.py sizes it to the next sweep
+        # pass, not the 12h queue slack that protects queued jobs.)
+        if record.deadline > 0 and now > record.deadline:
+            wake(record, "blind park past deadline", "deadline")
+        return
 
-        try:
-            states = [compute.status(jid) for jid in job_ids]
-        except SlurmQueryError:
-            # Layer 4's rule: query failure is "Slurm unknown", never "gone".
-            deferred.append(record.run_id)
-            return
+    try:
+        states = [compute.status(jid) for jid in job_ids]
+    except SlurmQueryError:
+        # Layer 4's rule: query failure is "Slurm unknown", never "gone".
+        deferred.append(record.run_id)
+        return
 
-        # deadline <= 0 cannot be written by save_record for waiting runs;
-        # if one exists anyway (legacy/hand-edited), treat it as already past
-        # for GONE — a vanished-experiment wake is safe — but never for
-        # PENDING, where the consequence would be cancelling a healthy job.
-        past_deadline = record.deadline <= 0 or now > record.deadline
-
-        if all(is_terminal(s) for s in states):
-            state = ",".join(sorted(set(states)))
-            # Layer 3, with real grace: time runs from when the sweep FIRST
-            # saw every job terminal, not from submission — the afterany
-            # job gets the full window to deliver before the backup steps in.
-            # Local compute has no afterany jobs to wait for (jobs are
-            # terminal at submit): the sweep IS the delivery, so grace would
-            # only cost a whole extra loop iteration.
-            if local_mode():
-                wake(record, f"experiment {state}", state)
-                return
-            if record.terminal_seen <= 0:
-                if dry_run:
-                    # no writes in dry-run: report the would-wake now so the
-                    # terminal path is visible to live plumbing checks
-                    wake(record, f"experiment {state}", state)
-                else:
-                    save_record(
-                        root,
-                        replace(
-                            record,
-                            terminal_seen=now,
-                            # repair legacy records as we touch them (see _wake)
-                            deadline=record.deadline if record.deadline > 0 else now,
-                        ),
-                        now,
-                    )
-                return
-            if now - record.terminal_seen >= grace_s:
+    # deadline <= 0 cannot be written by save_record for waiting runs;
+    # if one exists anyway (legacy/hand-edited), treat it as already past
+    # for GONE — a vanished-experiment wake is safe — but never for
+    # PENDING, where the consequence would be cancelling a healthy job.
+    past_deadline = record.deadline <= 0 or now > record.deadline
+
+    if all(is_terminal(s) for s in states):
+        state = ",".join(sorted(set(states)))
+        # Layer 3, with real grace: time runs from when the sweep FIRST
+        # saw every job terminal, not from submission — the afterany
+        # job gets the full window to deliver before the backup steps in.
+        # Local compute has no afterany jobs to wait for (jobs are
+        # terminal at submit): the sweep IS the delivery, so grace would
+        # only cost a whole extra loop iteration.
+        if local_mode():
+            wake(record, f"experiment {state}", state)
+            return
+        if record.terminal_seen <= 0:
+            if dry_run:
+                # no writes in dry-run: report the would-wake now so the
+                # terminal path is visible to live plumbing checks
                 wake(record, f"experiment {state}", state)
-        elif any(is_pending(s) for s in states) and record.deadline > 0 and now > record.deadline:
-            # Past the deadline with a job still queued. Ask Slurm WHY before
-            # calling it unschedulable: a busy queue or the account's own cap is
-            # a wait a scientist would sit out, so the deadline moves out by one
-            # slack window instead (Torch 2026-09-06: four launches pending on
-            # QOSMaxGRESPerUser were about to be cancelled and re-launched into
-            # the same cap). Local compute has no queue and no reasons.
-            pending = [j for j, s in zip(job_ids, states, strict=True) if is_pending(s)]
-            reason_of = getattr(compute, "pending_reason", None)
-            reasons: dict[str, str] = {}
-            if reason_of is not None:
-                try:
-                    reasons = {j: str(reason_of(j)) for j in pending}
-                except SlurmQueryError:
-                    deferred.append(record.run_id)  # unknown is never "cancel"
-                    return
-            if reasons and all(is_queue_wait(r) for r in reasons.values()):
-                extended = now + BLIND_PARK_SLACK_MIN * 60
-                if not dry_run:
-                    save_record(root, replace(record, deadline=extended), now)
-                log.info(
-                    "sweep: %s waits in the queue (%s); deadline extended by %d min",
-                    record.run_id,
-                    ", ".join(f"{j}={r}" for j, r in reasons.items()),
-                    BLIND_PARK_SLACK_MIN,
+            else:
+                save_record(
+                    root,
+                    replace(
+                        record,
+                        terminal_seen=now,
+                        # repair legacy records as we touch them (see _wake)
+                        deadline=record.deadline if record.deadline > 0 else now,
+                    ),
+                    now,
                 )
+            return
+        if now - record.terminal_seen >= grace_s:
+            wake(record, f"experiment {state}", state)
+    elif any(is_pending(s) for s in states) and record.deadline > 0 and now > record.deadline:
+        # Past the deadline with a job still queued. Ask Slurm WHY before
+        # calling it unschedulable: a busy queue or the account's own cap is
+        # a wait a scientist would sit out, so the deadline moves out by one
+        # slack window instead (Torch 2026-09-06: four launches pending on
+        # QOSMaxGRESPerUser were about to be cancelled and re-launched into
+        # the same cap). Local compute has no queue and no reasons.
+        pending = [j for j, s in zip(job_ids, states, strict=True) if is_pending(s)]
+        reason_of = getattr(compute, "pending_reason", None)
+        reasons: dict[str, str] = {}
+        if reason_of is not None:
+            try:
+                reasons = {j: str(reason_of(j)) for j in pending}
+            except SlurmQueryError:
+                deferred.append(record.run_id)  # unknown is never "cancel"
                 return
-            # Unschedulable in practice: cancel every non-terminal job
-            # (best-effort — scancel trouble must not abort the sweep), then
-            # wake with that fact.
+        if reasons and all(is_queue_wait(r) for r in reasons.values()):
+            extended = now + BLIND_PARK_SLACK_MIN * 60
             if not dry_run:
-                for jid, s in zip(job_ids, states, strict=True):
-                    if is_terminal(s) or s == GONE:
-                        continue
-                    try:
-                        compute.cancel(jid)
-                    except Exception as exc:  # scancel trouble is never fatal here
-                        log.warning("cancel %s failed: %s", jid, exc)
-            wake(record, "experiment unschedulable (pending past deadline)", "unschedulable")
-        elif all(is_terminal(s) or s == GONE for s in states):
-            # done-or-vanished, at least one GONE (all-terminal handled above)
-            if past_deadline:
-                wake(record, "experiment vanished from Slurm", "vanished")
-            # else: sacct lag right after submission is normal; wait.
-        # something RUNNING (or recently pending): nothing to do yet.
+                save_record(root, replace(record, deadline=extended), now)
+            log.info(
+                "sweep: %s waits in the queue (%s); deadline extended by %d min",
+                record.run_id,
+                ", ".join(f"{j}={r}" for j, r in reasons.items()),
+                BLIND_PARK_SLACK_MIN,
+            )
+            return
+        # Unschedulable in practice: cancel every non-terminal job
+        # (best-effort — scancel trouble must not abort the sweep), then
+        # wake with that fact.
+        if not dry_run:
+            for jid, s in zip(job_ids, states, strict=True):
+                if is_terminal(s) or s == GONE:
+                    continue
+                try:
+                    compute.cancel(jid)
+                except Exception as exc:  # scancel trouble is never fatal here
+                    log.warning("cancel %s failed: %s", jid, exc)
+        wake(record, "experiment unschedulable (pending past deadline)", "unschedulable")
+    elif all(is_terminal(s) or s == GONE for s in states):
+        # done-or-vanished, at least one GONE (all-terminal handled above)
+        if past_deadline:
+            wake(record, "experiment vanished from Slurm", "vanished")
+        # else: sacct lag right after submission is normal; wait.
+    # something RUNNING (or recently pending): nothing to do yet.
 
 
 def tick(
@@ -1838,7 +1848,19 @@ def tick(
     # no contract), and a live session waiting on `sync` must not depend on
     # whether github/contract loaded this tick.
     if followup_spec is not None:
-        service_syncs(root, followup_spec, now)
+        # ONE run-record snapshot for every READ-heavy service that follows the
+        # mutation phase (sweep/park/reap and housekeeping have already run and
+        # written what they will). Sharing it means walking runs/ once, not once
+        # per service. The launch lanes read a stale-but-conservative picture on
+        # purpose: the only record-writer between here and them is
+        # service_in_review, and it only ENDS runs (frees slots), so the
+        # snapshot can only OVER-count active runs — never launch a duplicate.
+        # The one exception is service_research_log, which PUBLISHES terminal
+        # outcomes: it reads fresh (below), never the snapshot. Any service
+        # that acts on a single record's CURRENT state re-reads that one
+        # record fresh via load_record (the freshness guard).
+        tick_records = list_runs(root)
+        service_syncs(root, followup_spec, now, tick_records)
     # a dry run reports and writes nothing: no download, no seed
     if github is not None and followup_spec is not None and followup_spec.target and not dry_run:
         try:
@@ -1914,8 +1936,13 @@ def tick(
             dry_run=followup_dry_run,
             allow_submit=launch_ok,
             contract=contract,
+            records=tick_records,
         )
         try:
+            # research_log reads FRESH, not the shared snapshot: it publishes
+            # terminal outcomes and writes done markers, and service_in_review
+            # just above may have ended a run this tick — a stale in-review
+            # record would be published as 'improved' and locked, wrong.
             service_research_log(root, github, spec, now)
         except Exception as exc:  # the ledger is advisory; the tick continues
             log.warning("research-log service failed: %s", exc)
@@ -1928,7 +1955,15 @@ def tick(
         )
         steward_job = (
             service_steward(
-                root, github, compute, spec, now, contract, limits, dry_run=followup_dry_run
+                root,
+                github,
+                compute,
+                spec,
+                now,
+                contract,
+                limits,
+                dry_run=followup_dry_run,
+                records=tick_records,
             )
             if launch_ok and intake_job is None and contract is not None
             else None
@@ -1944,6 +1979,7 @@ def tick(
                     now,
                     limits=limits,
                     dry_run=followup_dry_run,
+                    records=tick_records,
                 )
             except Exception as exc:
                 log.warning("self-initiated selection failed: %s", exc)
@@ -1978,7 +2014,9 @@ def service_eval_cache(root: Path, github: Any, target: str) -> str:
     return status
 
 
-def service_syncs(root: Path, spec: Any, now: float) -> None:
+def service_syncs(
+    root: Path, spec: Any, now: float, records: list[RunRecord] | None = None
+) -> None:
     """Honor mid-leg sync requests: a LIVE session asked for fresh origin/*
     refs and is waiting inside its own clock. The fetch pins the canonical
     URL (never the workspace's mutable remote config) and only refs/remotes
@@ -1989,7 +2027,9 @@ def service_syncs(root: Path, spec: Any, now: float) -> None:
     from outerloop.github import Workspace
     from outerloop.syscall import mark_synced, sync_requested
 
-    for record in list_runs(root):
+    if records is None:
+        records = list_runs(root)
+    for record in records:
         if record.state != IMPLEMENTING:
             continue
         workspace = run_dir(root, record.run_id) / "ws"
@@ -2022,10 +2062,15 @@ def service_boards(
     publish from the first tick (before any run ends), and a failure never
     stops the tick. With a compute backend, the strip also carries the
     kernel's queue (its own Slurm jobs, attributed to agents)."""
+    # ONE snapshot for the whole board pass: the climb rows, the live strip,
+    # and the queue's owner maps all read the SAME records, so they share it
+    # rather than each re-walking runs/. Taken here (end of tick) so a run
+    # ended earlier this tick already shows.
+    records = list_runs(root)
     try:
         from outerloop.climbboard import contract_directions, service_climb_board
 
-        service_climb_board(root, github, target, contract_directions(contract))
+        service_climb_board(root, github, target, contract_directions(contract), records)
     except Exception as exc:
         log.warning("climb board service failed: %s", exc)
     try:
@@ -2037,7 +2082,7 @@ def service_boards(
                 queue = compute.queue_snapshot()
             except Exception as exc:  # blind this tick: the strip publishes without a queue
                 log.warning("queue snapshot failed: %s", exc)
-        service_status(root, github, target, now, contract, queue=queue)
+        service_status(root, github, target, now, contract, queue=queue, records=records)
     except Exception as exc:  # each is advisory ALONE: one failing never mutes the other
         log.warning("status strip service failed: %s", exc)
 
@@ -2490,6 +2535,7 @@ def service_self_initiated(
     now: float,
     limits: EffectiveLimits | None = None,
     dry_run: bool = False,
+    records: list[RunRecord] | None = None,
 ) -> tuple[str, str] | None:
     """The default background mode: when nothing else needs doing, climb the
     least-recently-attempted benchmark.
@@ -2504,7 +2550,8 @@ def service_self_initiated(
         log.info("self-initiated lane paused (api outage: %s)", paused)
         return None
     try:
-        records = list_runs(root)
+        if records is None:
+            records = list_runs(root)
         width = _attempt_width(contract)
         # WIDTH: every live pending marker occupies a slot; landed ones
         # clear; dead ones become per-benchmark tombstones and free theirs.
@@ -2656,6 +2703,7 @@ def service_steward(
     contract: Any,
     limits: EffectiveLimits,
     dry_run: bool = False,
+    records: list[RunRecord] | None = None,
 ) -> tuple[str, str] | None:
     """The steward lane: claim at most ONE labeled work-order issue per tick
     and submit a stewardship job. Off until the operator provisions the
@@ -2673,7 +2721,8 @@ def service_steward(
 
         # ONE active run per target covers stewardships too: an env rewrite
         # must not fly alongside a solver climb or another stewardship.
-        records = list_runs(root)
+        if records is None:
+            records = list_runs(root)
         # reconcile first: killed jobs never post their own release — and
         # BEFORE the outage pause below, because a claim orphaned by the
         # very session the outage killed must not stay held all cooldown

{outerloop_science-0.1.0.dev3.dist-info → outerloop_science-0.1.0.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: outerloop-science
-Version: 0.1.0.dev3
+Version: 0.1.0.dev4
 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