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

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/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/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/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:

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

@@ -133,6 +133,9 @@ class JobSpec:
         return argv
 
 
+QUEUE_FIELDS = ("id", "name", "state", "elapsed", "partition", "submitted")
+
+
 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,6 +145,7 @@ 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: ...
 
@@ -257,6 +261,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"],
+                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
@@ -436,6 +460,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 ""
 

outerloop/followup.py

@@ -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.)_"
         )
@@ -1989,7 +2006,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(
         "--panel",