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

outerloop/attempt.py

@@ -18,6 +18,7 @@ import logging
 import os
 import re
 import shutil
+import time
 from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from dataclasses import replace as dc_replace
@@ -27,7 +28,7 @@ from typing import Any, cast
 
 from outerloop.appauth import resolve_bot_auth
 from outerloop.brief import BudgetState, distill_lessons
-from outerloop.compute import LocalCompute, local_mode
+from outerloop.compute import LocalCompute
 from outerloop.contract import Benchmark, Contract, contract_text_in_tree, load_contract
 from outerloop.dispatch import (
     Snapshot,
@@ -36,6 +37,7 @@ from outerloop.dispatch import (
     should_dispatch,
     snapshot_tree,
 )
+from outerloop.evalcache import seed_dir
 from outerloop.github import (
     GitError,
     GitHubClient,
@@ -43,8 +45,10 @@ from outerloop.github import (
     Workspace,
     contract_at,
     ensure_regular_git_dir,
+    git_identity,
 )
-from outerloop.harness import Harness, SessionResult, redact
+from outerloop.harness import Harness, SessionResult, default_binary, redact
+from outerloop.launchlog import append_ended, append_submitted, experiments_rows
 from outerloop.markers import has_marker
 from outerloop.measure import DispatchedMeasurer, DispatchSettings
 from outerloop.orchestrator import (
@@ -84,9 +88,20 @@ from outerloop.runstate import (
     save_record,
     stamp_outage,
 )
-from outerloop.syscall import CHANNEL_DIR_NAMES, MAX_ARTIFACT_BYTES, SyscallRequest, channel_dir
+from outerloop.runstate import (
+    run_dir as run_dir_of,
+)
+from outerloop.syscall import (
+    CHANNEL_DIR_NAMES,
+    MAX_ARTIFACT_BYTES,
+    SyscallRequest,
+    channel_dir,
+    launch_task_ids,
+    tool_update_note,
+)
 from outerloop.syscall import ensure_excluded as syscall_excluded
 from outerloop.syscall import install_tool as syscall_install_tool
+from outerloop.syscall import refresh_tool as syscall_refresh_tool
 from outerloop.syscall import write_budget as syscall_write_budget
 from outerloop.syscall import write_siblings as syscall_write_siblings
 from outerloop.verifier import MAX_CLAIM_CHARS
@@ -110,18 +125,19 @@ def resolve_author_key_file(backend: str, explicit: str = "") -> str:
     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 default path. For claude the
-    legacy spellings (`AUTORESEARCH_HARNESS_KEY_FILE`, `harness_key`) are still
+    legacy spellings (`AUTORESEARCH_HARNESS_KEY_FILE`, read through its bridged
+    `OUTERLOOP_` twin, and `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
+            explicit = os.environ.get("OUTERLOOP_CODEX_KEY_FILE") or CODEX_KEY_DEFAULT
         else:
             explicit = (
-                os.environ.get("AUTORESEARCH_CLAUDE_KEY_FILE")
-                or os.environ.get("AUTORESEARCH_HARNESS_KEY_FILE")
+                os.environ.get("OUTERLOOP_CLAUDE_KEY_FILE")
+                or os.environ.get("OUTERLOOP_HARNESS_KEY_FILE")
                 or ""
             )
             if not explicit:
@@ -140,14 +156,14 @@ def codex_author_config_error(backend: str, model: str, image: str) -> str:
     a unit and never a fleet backend against a run's model. codex writes+executes,
     so it must be contained (--image) and needs a non-claude model."""
     if backend not in ("claude", "codex"):
-        # a typo'd AUTORESEARCH_AUTHOR_BACKEND passes the env DEFAULT silently
+        # a typo'd OUTERLOOP_AUTHOR_BACKEND passes the env DEFAULT silently
         # (argparse validates the flag, not its default) and the climb rejects it
         # at build_harness — catch it on the tick host so a claimed intake
         # issue never strands on it
         return f"unknown author backend {backend!r} (expected 'claude' or 'codex')"
     if backend == "claude":
         # symmetric to the codex check: a claude harness 404s on a non-claude
-        # model (e.g. AUTORESEARCH_AUTHOR_MODEL left on a codex id while the
+        # model (e.g. OUTERLOOP_AUTHOR_MODEL left on a codex id while the
         # backend is claude) — catch that misconfig before spend
         if model and not model.startswith("claude"):
             return f"author-backend claude needs a claude model (got {model!r})"
@@ -185,7 +201,7 @@ class WorkspaceDrift(RuntimeError):
     """The tree changed between measurement and commit."""
 
 
-def _target_clone_url(target: str) -> str:
+def target_clone_url(target: str) -> str:
     """The canonical HTTPS clone URL for `owner/repo`. The one source of truth
     for where a run's git pushes go — derived from the target, never read from
     the session-writable `remote.origin.url`."""
@@ -205,7 +221,8 @@ def _blessed_head(ws: Workspace, result: Any, contract: Any) -> str:
         return ""
     try:
         return ws.git("rev-parse", "HEAD").strip()
-    except Exception:
+    except Exception as exc:
+        log.warning("could not read HEAD; not arming self-merge: %s", exc)
         return ""
 
 
@@ -424,9 +441,14 @@ def _park_run(
         # it lands in the durable record, like every other persisted final_text
         # — a session that echoed a credential must not leave it in record.json.
         # Empty/zero for a baseline park (the session has not run yet).
-        "report": redact(parked.session.final_text, secrets)[:MAX_CLAIM_CHARS]
-        if parked.session
-        else "",
+        # the author's report at submit, else the session's last words (a park
+        # with no submit); either way what the wake's panel and the PR body read
+        "report": redact(
+            parked.syscall.report
+            if parked.syscall is not None and parked.syscall.report
+            else (parked.session.final_text if parked.session else ""),
+            secrets,
+        )[:MAX_CLAIM_CHARS],
         "session_cost_usd": parked.session.cost_usd if parked.session else 0.0,
         "session_turns": parked.session.num_turns if parked.session else 0,
     }
@@ -451,10 +473,35 @@ def _park_run(
                 "minutes": launch.minutes,
                 "artifacts": list(launch.artifacts),
                 **({"array": launch.array} if launch.array > 1 else {}),
+                **({"why": redact(launch.why, secrets)} if launch.why else {}),
+                **({"concurrency": launch.concurrency} if launch.concurrency else {}),
             }
             for launch in parked.syscall.launches
         ]
         stage["syscall_note"] = redact(parked.syscall.note, secrets)
+        if parked.syscall.launches:
+            # the run's launch ledger (`history`, and the queue view's labels):
+            # ids align with launch_jobs order, as stage_launch_job_ids reads them
+            if parked.launch_afterany:
+                launch_ids = afterany_ids(parked.launch_afterany)
+            elif parked.phase == "author-sleep":
+                launch_ids = list(job_ids)
+            else:
+                launch_ids = []
+            ledger_launches = tuple(
+                dc_replace(launch, why=redact(launch.why, secrets))
+                for launch in parked.syscall.launches
+            )
+            _best_effort(
+                "launch ledger",
+                lambda: append_submitted(
+                    run_dir_of(run_root, record.run_id),
+                    sleep=parked.sleeps_used,
+                    launches=ledger_launches,
+                    job_ids=launch_ids,
+                    at=now,
+                ),
+            )
         # (the session id the wake resumes is the record's own
         # resume_session_id, set below for every park — no stage duplicate)
         stage["launches_used"] = parked.launches_used
@@ -585,6 +632,7 @@ def _dispatch_settings(args: argparse.Namespace) -> DispatchSettings:
     #174: the wake dropped the GPU lane)."""
     from outerloop.compute import compute_from_env
 
+    target = getattr(args, "target", "") or ""
     return DispatchSettings(
         compute=compute_from_env(),
         image=args.image,
@@ -592,9 +640,34 @@ def _dispatch_settings(args: argparse.Namespace) -> DispatchSettings:
         partition=args.partition,
         gpu_partition=getattr(args, "gpu_partition", ""),
         gpu_account=getattr(args, "gpu_account", ""),
+        seed_cache=seed_dir(Path(args.run_root), target) if target else None,
     )
 
 
+# Experiments yield to verification. Every kernel job is one Slurm user, so
+# among the kernel's own pending jobs the priority order is ours: launches
+# carry this nice so a gate eval or a follow-up re-measure (nice 0) starts
+# first when the cap frees a slot. Sized above the factors that differ between
+# our jobs on Torch — age tops out at 1000 after a week, job size at 1000, the
+# per-GPU TRES share stays in the hundreds — so the order holds however long a
+# launch has waited. Other users' jobs and the group cap are untouched.
+LAUNCH_NICE = 5000
+
+
+def with_seed(dispatch: DispatchSettings, run_root: Path, target: str) -> DispatchSettings:
+    """These settings with the target's seed cache filled in from the record's
+    target when the CLI gave none (wake and follow-up jobs carry the run id,
+    not the target)."""
+    # tolerant of any settings object: a backend that knows no seed (or a
+    # test double) is left exactly as it is
+    if not target or getattr(dispatch, "seed_cache", "unknown") is not None:
+        return dispatch
+    try:
+        return dc_replace(dispatch, seed_cache=seed_dir(run_root, target))
+    except TypeError:
+        return dispatch
+
+
 def _make_launcher(
     dispatch: DispatchSettings, run_dir: Path, workspace: Path, run_id: str, gpus: int = 0
 ):
@@ -607,38 +680,39 @@ def _make_launcher(
 
     def launcher(sha: str, request: SyscallRequest) -> str:
         from outerloop.dispatch import eval_job_spec, write_eval_job
-        from outerloop.syscall import launch_jobs
+        from outerloop.syscall import array_spec
 
         ids: list[str] = []
         try:
             for launch in request.launches:
-                # an array launch is N jobs of one command, each with its
-                # SWEEP_INDEX; one afterany wake covers them all
-                for job_name, extra_env in launch_jobs(launch):
-                    script = write_eval_job(
-                        run_dir,
-                        f"launch-{job_name}",
-                        repo_root=workspace,
-                        snapshot_sha=sha,
-                        command=launch.command,
-                        image=dispatch.image,
-                        extra_env=extra_env,
-                        artifacts=launch.artifacts,
-                        artifact_max_bytes=MAX_ARTIFACT_BYTES,
-                        gpus=gpus,
-                    )
-                    ids.append(
-                        dispatch.compute.submit(
-                            eval_job_spec(
-                                script,
-                                job_name=f"{run_id}-launch-{job_name}",
-                                account=account,
-                                partition=partition,
-                                eval_minutes=launch.minutes,
-                                gpus=gpus,
-                            )
-                        )
-                    )
+                # a sweep is ONE Slurm job array (`--array=0-N%K`): the queue
+                # holds one entry, Slurm runs at most K tasks at once, each task
+                # derives its job dir and SWEEP_INDEX from its array index, and
+                # one afterany on the array id covers every task
+                script = write_eval_job(
+                    run_dir,
+                    f"launch-{launch.name}",
+                    repo_root=workspace,
+                    snapshot_sha=sha,
+                    command=launch.command,
+                    image=dispatch.image,
+                    artifacts=launch.artifacts,
+                    artifact_max_bytes=MAX_ARTIFACT_BYTES,
+                    gpus=gpus,
+                    array=launch.array,
+                    seed_cache=dispatch.seed_cache,
+                )
+                spec = eval_job_spec(
+                    script,
+                    job_name=f"{run_id}-launch-{launch.name}",
+                    account=account,
+                    partition=partition,
+                    eval_minutes=launch.minutes,
+                    gpus=gpus,
+                    nice=LAUNCH_NICE,
+                    array=array_spec(launch),
+                )
+                ids.append(dispatch.compute.submit(spec))
         except Exception:
             # a partial batch must not orphan: no park record was written yet,
             # so nothing would ever wake or cancel the jobs that DID submit —
@@ -656,6 +730,26 @@ def _make_launcher(
     return launcher
 
 
+def _make_watcher(
+    dispatch: DispatchSettings, run_root: Path, run_id: str, workspace: Path, config: RunConfig
+) -> Callable[[], Any]:
+    """The session watcher for one run: a thread beside the harness that
+    answers `queue` and `history` from the channel (docs/design/session-watcher.md).
+    Shared by the first pass and every wake leg."""
+    from outerloop.watcher import SessionWatcher, WatcherContext
+
+    ctx = WatcherContext(
+        workspace=workspace,
+        run_root=run_root,
+        run_id=run_id,
+        target=config.target,
+        agent_id=config.agent_id,
+        compute=dispatch.compute,
+        gpu_partition=dispatch.gpu_partition,
+    )
+    return lambda: SessionWatcher(ctx)
+
+
 def _wake_author_sleep(
     *,
     run_root: Path,
@@ -708,7 +802,12 @@ def _wake_author_sleep(
         # the same ending shape every other terminal takes. The line notebook
         # records it first, while the tree is still the session's final tree.
         _push_line_snapshot(
-            ws, _line_ref_for(bench, config.agent_id), run_id, result.outcome, secrets
+            ws,
+            _line_ref_for(bench, config.agent_id),
+            run_id,
+            result.outcome,
+            secrets,
+            bot_login=config.bot_login,
         )
         for ref in drop_refs:
             drop_snapshot(ws, Snapshot(commit="", tree="", ref=ref))
@@ -771,6 +870,8 @@ def _wake_author_sleep(
             minutes=int(item.get("minutes") or 1),
             artifacts=tuple(str(a) for a in item.get("artifacts", [])),
             array=int(item.get("array") or 1),
+            why=str(item.get("why") or ""),
+            concurrency=int(item.get("concurrency") or 0),
         )
         for item in _stage_launches(record)
     )
@@ -781,12 +882,28 @@ def _wake_author_sleep(
     # of a blank "job failure". The park's launch job ids align positionally
     # with the results (same launch/array order). Best-effort — the wake never
     # blocks on the scheduler query.
+    task_ids = launch_task_ids(launches, stage_launch_job_ids(record))
     status_of = getattr(dispatch.compute, "status", None)
     if status_of is not None:
-        results = annotate_launch_states(results, _stage_launch_job_ids(record), status_of)
+        results = annotate_launch_states(results, task_ids, status_of)
     launches_used = int(record.stage.get("launches_used", 0))  # type: ignore[call-overload]
     sleeps_used = int(record.stage.get("sleeps_used", 0))  # type: ignore[call-overload]
-    gpu_hours_used = _reconcile_launch_hours(record, dispatch, bench.gpus, launches)
+    elapsed = _launch_elapsed(dispatch, task_ids) if task_ids else None
+    _best_effort(
+        "launch ledger",
+        lambda: append_ended(
+            run_dir, sleep=sleeps_used, results=results, at=time.time(), elapsed_seconds=elapsed
+        ),
+    )
+    gpu_hours_used = _reconcile_launch_hours(record, dispatch, bench.gpus, launches, elapsed)
+    # the tool the session invokes comes from THIS kernel: a session that
+    # started under an older one gets today's verbs and flags at its wake, and
+    # is told what is new
+    tool_changed = False
+    try:
+        tool_changed = syscall_refresh_tool(workspace)
+    except Exception as exc:
+        log.warning("tool refresh failed: %s", redact(f"{type(exc).__name__}: {exc}", secrets))
     wake_text = render_wake(
         results,
         str(record.stage.get("syscall_note", "")),
@@ -799,6 +916,15 @@ def _wake_author_sleep(
         ),
         gpus=bench.gpus,
     )
+    pacing = [
+        f"sweep `{la.name}`: {la.array} tasks, at most {la.concurrency or la.array} at a time"
+        for la in launches
+        if la.array > 1
+    ]
+    if pacing:
+        wake_text = f"{wake_text}\n\n" + "\n".join(pacing) + " (the contract's ceiling applies)."
+    if tool_changed:
+        wake_text = f"{wake_text}\n\n{tool_update_note(channel_dir(workspace))}"
     if extra_update:
         # a submitted park's gate/panel feedback leads; launch results follow
         wake_text = f"{extra_update}\n\n{wake_text}"
@@ -824,7 +950,9 @@ def _wake_author_sleep(
     wake_line = _line_ref_for(bench, config.agent_id)
 
     def snapshot() -> str:
-        snap = snapshot_tree(ws, base_sha, exclude=LINE_MEMORY_PATHS if wake_line else ())
+        snap = snapshot_tree(
+            ws, base_sha, exclude=LINE_MEMORY_PATHS if wake_line else (), author=config.bot_login
+        )
         snapshots.append(snap)
         return snap.commit
 
@@ -845,6 +973,7 @@ def _wake_author_sleep(
             config.bot_login,
             _utc_date(now),
             exclude=LINE_MEMORY_PATHS if wake_line else (),
+            secrets=secrets,
         )
         if panel_lenses
         else None
@@ -868,6 +997,7 @@ def _wake_author_sleep(
             resume_session_id=record.resume_session_id,
             improve_prompt=wake_text,
             launcher=_make_launcher(dispatch, run_dir, workspace, run_id, gpus=bench.gpus),
+            watcher=_make_watcher(dispatch, run_root, run_id, workspace, config),
             tree_of=lambda sha: ws.git("rev-parse", f"{sha}^{{tree}}").strip(),
             judged=judged or _stage_judged(record),
             launches_used=launches_used,
@@ -932,6 +1062,32 @@ def _stage_judged(record: RunRecord) -> tuple[str, AttemptResult] | None:
     )
 
 
+def _ledger_ended(
+    run_dir: Path,
+    record: RunRecord,
+    launches: tuple,
+    task_ids: list[str],
+    dispatch: DispatchSettings,
+    elapsed: list[int | None] | None,
+) -> None:
+    """Record a park's finished launches in the ledger from the run dir alone
+    (no delivery into a workspace), with the scheduler's state for jobs that
+    left no exit code."""
+    from outerloop.syscall import annotate_launch_states, read_results
+
+    results = read_results(run_dir, launches)
+    status_of = getattr(dispatch.compute, "status", None)
+    if status_of is not None:
+        results = annotate_launch_states(results, task_ids, status_of)
+    append_ended(
+        run_dir,
+        sleep=int(record.stage.get("sleeps_used", 0)),  # type: ignore[call-overload]
+        results=results,
+        at=time.time(),
+        elapsed_seconds=elapsed,
+    )
+
+
 def _stage_syscall_launches(record: RunRecord) -> tuple:
     """The park's launches as `Launch` values (command elided: they ran)."""
     from outerloop.syscall import Launch
@@ -943,12 +1099,14 @@ def _stage_syscall_launches(record: RunRecord) -> tuple:
             minutes=int(item.get("minutes") or 1),
             artifacts=tuple(str(a) for a in item.get("artifacts", [])),
             array=int(item.get("array") or 1),
+            why=str(item.get("why") or ""),
+            concurrency=int(item.get("concurrency") or 0),
         )
         for item in _stage_launches(record)
     )
 
 
-def _stage_launch_job_ids(record: RunRecord) -> list[str]:
+def stage_launch_job_ids(record: RunRecord) -> list[str]:
     """The park's launch jobs: `launch_afterany` when the park recorded it;
     for an older author-sleep park every waited job was a launch; for an
     older candidate park the gate's evals are mixed in, so none."""
@@ -961,7 +1119,11 @@ def _stage_launch_job_ids(record: RunRecord) -> list[str]:
 
 
 def _reconcile_launch_hours(
-    record: RunRecord, dispatch: DispatchSettings, gpus: int, launches: tuple
+    record: RunRecord,
+    dispatch: DispatchSettings,
+    gpus: int,
+    launches: tuple,
+    elapsed: list[int | None] | None = None,
 ) -> float:
     """The run's GPU-hours after handing back the unused walltime of the
     park's launch jobs — once: the stage remembers the refund, so a wake
@@ -971,7 +1133,9 @@ def _reconcile_launch_hours(
     used = float(stage.get("gpu_hours_used", 0.0))  # type: ignore[arg-type]
     if not gpus or stage.get("launch_hours_refunded"):
         return used
-    refund = _launch_refund(dispatch, launches, _stage_launch_job_ids(record), gpus)
+    refund = _launch_refund(
+        dispatch, launches, launch_task_ids(launches, stage_launch_job_ids(record)), gpus, elapsed
+    )
     if refund > 0:
         log.info("%s: refunding %.2f GPU-hours of unused launch walltime", record.run_id, refund)
         used = max(0.0, used - refund)
@@ -980,21 +1144,35 @@ def _reconcile_launch_hours(
     return used
 
 
+def _launch_elapsed(dispatch: DispatchSettings, job_ids: list[str]) -> list[int | None] | None:
+    """How long each launch job ran, from the compute, aligned with `job_ids`;
+    None when the compute cannot say (nothing is refunded or recorded on a
+    guess)."""
+    query = getattr(dispatch.compute, "elapsed_seconds", None)
+    if query is None or not job_ids:
+        return None
+    try:
+        return [query(jid) for jid in job_ids]
+    except Exception as exc:
+        log.warning("launch walltime unknown (%s: %s)", type(exc).__name__, exc)
+        return None
+
+
 def _launch_refund(
-    dispatch: DispatchSettings, launches: tuple, job_ids: list[str], gpus: int
+    dispatch: DispatchSettings,
+    launches: tuple,
+    job_ids: list[str],
+    gpus: int,
+    elapsed: list[int | None] | None = None,
 ) -> float:
     """The unused walltime of a park's launch jobs, in GPU-hours, or 0 when
     the compute cannot say how long they ran (nothing is refunded on a
-    guess)."""
+    guess). `elapsed` may be handed in when the caller already asked."""
     from outerloop.syscall import launch_hours_refund
 
-    query = getattr(dispatch.compute, "elapsed_seconds", None)
-    if query is None or not job_ids:
-        return 0.0
-    try:
-        elapsed = [query(jid) for jid in job_ids]
-    except Exception as exc:
-        log.warning("launch walltime unknown (%s: %s); nothing refunded", type(exc).__name__, exc)
+    if elapsed is None:
+        elapsed = _launch_elapsed(dispatch, job_ids)
+    if elapsed is None:
         return 0.0
     return launch_hours_refund(launches, elapsed, gpus=gpus)
 
@@ -1119,7 +1297,12 @@ def _line_ref_for(bench: Benchmark | None, agent_id: str) -> str:
 
 
 def _push_line_snapshot(
-    ws: Workspace, line_ref: str, run_id: str, outcome: str, secrets: tuple[str, ...] = ()
+    ws: Workspace,
+    line_ref: str,
+    run_id: str,
+    outcome: str,
+    secrets: tuple[str, ...] = (),
+    bot_login: str = "",
 ) -> None:
     """Publish the session's final tree to the agent's line as a sealed
     snapshot commit — every terminal path, any outcome
@@ -1162,7 +1345,7 @@ def _push_line_snapshot(
                     fork = parent = remote
             except Exception as exc:
                 log.info("line %s: sealing on the local ref (%s)", line_ref, type(exc).__name__)
-            snap = snapshot_tree(ws, parent, force=memory)
+            snap = snapshot_tree(ws, parent, force=memory, author=bot_login)
             try:
                 # seal only when the tree moved past the parent; the PUSH runs
                 # either way — a session that COMMITTED its work advanced the
@@ -1171,10 +1354,7 @@ def _push_line_snapshot(
                 sealed = parent
                 if snap.tree != ws.git("rev-parse", f"{parent}^{{tree}}").strip():
                     sealed = ws.git(
-                        "-c",
-                        "user.name=autoresearch",
-                        "-c",
-                        "user.email=autoresearch@localhost",
+                        *git_identity(bot_login),
                         "commit-tree",
                         snap.tree,
                         "-p",
@@ -1234,7 +1414,9 @@ def _reconcile_with_remote(ws: Workspace, old: str, new: str) -> None:
             ws.git("checkout", new, "--", path)
 
 
-def _checkout_line(ws: Workspace, workspace: Path, agent_id: str, base_branch: str) -> str:
+def _checkout_line(
+    ws: Workspace, workspace: Path, agent_id: str, base_branch: str, bot_login: str = ""
+) -> str:
     """Check out the agent's research line: the persistent branch
     `agents/<agent-id>`, created from the base branch when absent, with the
     base branch merged in when it exists — a conflicted merge is left in the
@@ -1254,10 +1436,7 @@ def _checkout_line(ws: Workspace, workspace: Path, agent_id: str, base_branch: s
     conflicted = False
     try:
         ws.git(
-            "-c",
-            "user.name=autoresearch",
-            "-c",
-            "user.email=autoresearch@localhost",
+            *git_identity(bot_login),
             "merge",
             "--no-edit",
             base_ref,
@@ -1272,10 +1451,7 @@ def _checkout_line(ws: Workspace, workspace: Path, agent_id: str, base_branch: s
         ws.git("add", "-A")
         if ws.git("status", "--porcelain").strip():
             ws.git(
-                "-c",
-                "user.name=autoresearch",
-                "-c",
-                "user.email=autoresearch@localhost",
+                *git_identity(bot_login),
                 "commit",
                 "-q",
                 "-m",
@@ -1461,12 +1637,13 @@ def resume_run(
     run_dir = run_root / "runs" / run_id
     workspace = run_dir / "ws"
     record = load_record(run_root, run_id)
+    dispatch = with_seed(dispatch, run_root, record.target)
     stage = record.stage
     # Push to the CANONICAL target URL, never the workspace's remote.origin.url:
     # the session could have rewritten that config to exfil the bot token / code
     # to another remote. Passing `url` here means `Workspace.push` uses it
     # instead of reading `remote.origin.url`.
-    ws = Workspace(root=workspace, auth=bot_auth, url=_target_clone_url(record.target))
+    ws = Workspace(root=workspace, auth=bot_auth, url=target_clone_url(record.target))
     # A session reshaped .git (symlinked object store, gitdir file, FIFO) is
     # refused BEFORE anything writes through it: the exclude below opens
     # .git/info/exclude, and every ws.git call re-checks. The refusal ENDS
@@ -1638,11 +1815,16 @@ def resume_run(
                             minutes=int(item.get("minutes") or 1),
                             artifacts=tuple(str(a) for a in item.get("artifacts", [])),
                             array=int(item.get("array") or 1),
+                            why=str(item.get("why") or ""),
+                            concurrency=int(item.get("concurrency") or 0),
                         )
                         for item in _stage_launches(record)
                     ),
                     note=str(stage.get("syscall_note", "")),
                     submit=True,
+                    # the author's report rides every re-park: a suite fan-out
+                    # must not drop what the panel and the PR read
+                    report=str(stage.get("report", "")),
                 )
         old_afterany = str(record.stage.get("afterany", ""))
         made_progress = bool(parked.afterany) and parked.afterany != old_afterany
@@ -1677,7 +1859,19 @@ def resume_run(
     # the park's sibling launches are done too: settle their charge before
     # any path — publish or hand back to the author — reads the budget
     if _stage_launches(record):
-        _reconcile_launch_hours(record, dispatch, bench.gpus, _stage_syscall_launches(record))
+        sibling_launches = _stage_syscall_launches(record)
+        sibling_ids = launch_task_ids(sibling_launches, stage_launch_job_ids(record))
+        sibling_elapsed = _launch_elapsed(dispatch, sibling_ids) if sibling_ids else None
+        _reconcile_launch_hours(record, dispatch, bench.gpus, sibling_launches, sibling_elapsed)
+        # the ledger's ended records for the sibling launches, whether or not
+        # the author is woken: the PR's experiments table reads them (an
+        # author wake that follows records nothing twice)
+        _best_effort(
+            "launch ledger",
+            lambda: _ledger_ended(
+                run_dir, record, sibling_launches, sibling_ids, dispatch, sibling_elapsed
+            ),
+        )
 
     def _wake_author(
         extra_update: str, judged: tuple[str, AttemptResult] | None = None
@@ -1736,7 +1930,14 @@ def resume_run(
         # Research lines: record the tree AS OF THIS DECIDED TERMINAL — never
         # earlier, because a blocking panel verdict can still resume the
         # author (a continuation, not a terminal).
-        _push_line_snapshot(ws, _line_ref_for(bench, config.agent_id), run_id, outcome, secrets)
+        _push_line_snapshot(
+            ws,
+            _line_ref_for(bench, config.agent_id),
+            run_id,
+            outcome,
+            secrets,
+            bot_login=config.bot_login,
+        )
 
     if result.outcome == "improved":
         # Publish: branch the SEALED candidate sha, fold in the ledger, push,
@@ -1883,6 +2084,7 @@ def resume_run(
                         exclude=(
                             LINE_MEMORY_PATHS if _line_ref_for(bench, config.agent_id) else ()
                         ),
+                        secrets=secrets,
                     )(baseline, candidate, str(stage.get("report", "")))
                 except Exception as exc:
                     if isinstance(exc, GitError) and _is_git_tamper(exc):
@@ -1950,18 +2152,23 @@ def resume_run(
             # so push the candidate as-is rather than an empty commit.
             if staged:
                 ws.git(
-                    "-c",
-                    f"user.name={config.bot_login}",
-                    "-c",
-                    f"user.email={config.bot_login}@users.noreply.github.com",
+                    *git_identity(config.bot_login),
                     "commit",
                     "-m",
                     f"agent: improve {config.benchmark} ({_title_pair(baseline, candidate)})"
                     f"\n\nAgent: {config.agent_id}",
                 )
             ws.push(branch)
+            if record.stage.get("submitted"):
+                # the author's report at submit rides the stage: the PR shows it
+                # as the research report, over the ledger's experiments
+                result = dc_replace(result, submit_report=str(record.stage.get("report") or ""))
             body = pr_body(
-                result, config, redact_secrets=secrets, display_digits=bench.display_digits
+                result,
+                config,
+                redact_secrets=secrets,
+                display_digits=bench.display_digits,
+                experiments=experiments_rows(run_dir),
             )
             if issue_number:
                 body = f"Addresses #{issue_number}.\n\n{body}"
@@ -2171,7 +2378,7 @@ def _panel_lenses_from_args(args: Any) -> tuple[tuple[PanelLens, ...], tuple[str
         if backend == "codex":
             lens_key = _judge_lens_key(
                 backend="codex",
-                key_file_env="AUTORESEARCH_PANEL_CODEX_KEY_FILE",
+                key_file_env="OUTERLOOP_PANEL_CODEX_KEY_FILE",
                 author_backend="codex",
                 claude_panel_path=claude_panel_path,
                 image=args.image,
@@ -2185,7 +2392,7 @@ def _panel_lenses_from_args(args: Any) -> tuple[tuple[PanelLens, ...], tuple[str
             # separate against the codex author key.
             lens_key = _judge_lens_key(
                 backend="hermes",
-                key_file_env="AUTORESEARCH_PANEL_HERMES_KEY_FILE",
+                key_file_env="OUTERLOOP_PANEL_HERMES_KEY_FILE",
                 author_backend="codex",
                 claude_panel_path=claude_panel_path,
                 image=args.image,
@@ -2259,6 +2466,7 @@ def build_panel_runner(
     start_round: int = 0,
     exclude: tuple[str, ...] = (),
     claim_body: Callable[[float, float, str], str] | None = None,
+    secrets: tuple[str, ...] = (),
 ) -> Callable[[float, float, str], PanelVerdict]:
     """The git half of the pre-PR panel: prepare the two read-only checkouts
     and the synthetic claim, then hand off to `run_panel` (which owns no git).
@@ -2282,6 +2490,10 @@ def build_panel_runner(
     )
 
     def runner(baseline: float, candidate: float, report: str) -> PanelVerdict:
+        # the claim is author text (the report at submit, or the session's
+        # last words): redacted before any lens sees it, like the record and
+        # the PR body
+        report = redact(report, secrets)
         reads["n"] += 1
         panel_ws = run_dir / "panel"
         shutil.rmtree(panel_ws, ignore_errors=True)
@@ -2294,10 +2506,7 @@ def build_panel_runner(
         tree = ws.git("write-tree").strip()
         ws.git("reset")
         snapshot = ws.git(
-            "-c",
-            "user.name=panel",
-            "-c",
-            "user.email=panel@localhost",
+            *git_identity(bot_login),
             "commit-tree",
             tree,
             "-p",
@@ -2427,7 +2636,7 @@ def live_attempt(
     # exception path cannot rely on names bound inside the try
     salvage: dict[str, object] = {}
     try:
-        ws = Workspace.clone(_target_clone_url(config.target), workspace, auth=bot_auth)
+        ws = Workspace.clone(target_clone_url(config.target), workspace, auth=bot_auth)
         # Build ON the requested PR base: the clone checks out the remote
         # DEFAULT branch, which need not be `base_branch` — the session must
         # edit, and the gate must measure, the tree the PR will land on.
@@ -2491,7 +2700,9 @@ def live_attempt(
         line_ref = ""
         if lines_active:
             try:
-                line_ref = _checkout_line(ws, workspace, config.agent_id, base_branch)
+                line_ref = _checkout_line(
+                    ws, workspace, config.agent_id, base_branch, config.bot_login
+                )
             except Exception as exc:
                 log.warning(
                     "line checkout failed (%s); running on %s",
@@ -2634,6 +2845,7 @@ def live_attempt(
                 config.bot_login,
                 created[:10],
                 exclude=LINE_MEMORY_PATHS if lines_active else (),
+                secrets=secrets,
             )
             if panel_lenses
             else None
@@ -2667,12 +2879,16 @@ def live_attempt(
                 run_tag=run_id,
                 # an inline gate shares the same target-wide baseline cache
                 baseline_cache=run_dir.parent / "baselines",
+                seed_cache=dispatch.seed_cache if dispatch is not None else None,
             )
         snapshots: list[Snapshot] = []
 
         def snapshot() -> str:
             snap = snapshot_tree(
-                ws, pre_session_sha, exclude=LINE_MEMORY_PATHS if lines_active else ()
+                ws,
+                pre_session_sha,
+                exclude=LINE_MEMORY_PATHS if lines_active else (),
+                author=config.bot_login,
             )
             snapshots.append(snap)
             return snap.commit
@@ -2717,6 +2933,11 @@ def live_attempt(
                 line_memory=line_memory,
                 line_divergence=line_divergence,
                 launcher=launcher,
+                watcher=(
+                    _make_watcher(dispatch, run_root, run_id, workspace, config)
+                    if dispatch is not None
+                    else None
+                ),
                 tree_of=lambda sha: ws.git("rev-parse", f"{sha}^{{tree}}").strip(),
             )
         except RunParked as p:
@@ -2781,6 +3002,7 @@ def live_attempt(
                 run_id,
                 "attempt-error",
                 secrets,
+                bot_login=config.bot_login,
             )
         failed = RunRecord(
             **{
@@ -2838,7 +3060,7 @@ def live_attempt(
     # memory (it is excluded from measurable seals by design). The label is
     # the GATE outcome, correct at this moment; a publish failure appends a
     # publish-error snapshot at the tail.
-    _push_line_snapshot(ws, line_ref, run_id, result.outcome, secrets)
+    _push_line_snapshot(ws, line_ref, run_id, result.outcome, secrets, bot_login=config.bot_login)
 
     pr_url = ""
     outcome_name = result.outcome
@@ -2890,10 +3112,7 @@ def live_attempt(
                 raise WorkspaceDrift(f"publish would stage non-ledger paths: {extra[:10]}")
             if staged:
                 ws.git(
-                    "-c",
-                    f"user.name={config.bot_login}",
-                    "-c",
-                    f"user.email={config.bot_login}@users.noreply.github.com",
+                    *git_identity(config.bot_login),
                     "commit",
                     "-m",
                     f"agent: improve {config.benchmark} ({_title_pair(baseline, candidate)})"
@@ -2902,7 +3121,11 @@ def live_attempt(
             ws.push(branch)
             pushed = True
             body = pr_body(
-                result, config, redact_secrets=secrets, display_digits=bench.display_digits
+                result,
+                config,
+                redact_secrets=secrets,
+                display_digits=bench.display_digits,
+                experiments=experiments_rows(run_dir),
             )
             if issue_number:
                 body = f"Addresses #{issue_number}.\n\n{body}"
@@ -3017,7 +3240,7 @@ def live_attempt(
         # the publish failed after the gate credited the tree: the improved
         # snapshot above stands (the measurement was real); append the
         # publish-error marker so the notebook records how the run ended
-        _push_line_snapshot(ws, line_ref, run_id, outcome_name, secrets)
+        _push_line_snapshot(ws, line_ref, run_id, outcome_name, secrets, bot_login=config.bot_login)
     log.info("run %s: %s %s", run_id, outcome_name, pr_url)
     return AttemptOutcome(
         run_id=run_id,
@@ -3110,7 +3333,6 @@ def arm_sigterm_containment() -> None:
 def main() -> int:
     import argparse
     import os
-    import time
     from datetime import UTC, datetime
 
     arm_sigterm_containment()
@@ -3143,45 +3365,48 @@ def main() -> int:
     )
     parser.add_argument("--base-branch", default="main")
     # All three default from the chain env the tick sets on the climb job, so
-    # a contained run with AUTORESEARCH_{IMAGE,ACCOUNT,PARTITION} set selects
-    # dispatched measurement without extra flags. The image also containers the
-    # session + inline eval; absent any of the three, measurement stays inline
-    # regardless of the benchmark's eval hint.
+    # a contained run with OUTERLOOP_{IMAGE,ACCOUNT,PARTITION} set selects
+    # dispatched measurement without extra flags. Only the image is required
+    # for dispatch (it also contains the session + inline eval); without it,
+    # measurement stays inline regardless of the benchmark's eval hint. Empty
+    # account/partition use Slurm's defaults.
     parser.add_argument(
         "--image",
-        default=os.environ.get("AUTORESEARCH_IMAGE", ""),
+        default=os.environ.get("OUTERLOOP_IMAGE", ""),
         help="apptainer image for session+eval",
     )
-    parser.add_argument("--account", default=os.environ.get("AUTORESEARCH_ACCOUNT", ""))
-    parser.add_argument("--partition", default=os.environ.get("AUTORESEARCH_PARTITION", ""))
+    parser.add_argument("--account", default=os.environ.get("OUTERLOOP_ACCOUNT", ""))
+    parser.add_argument("--partition", default=os.environ.get("OUTERLOOP_PARTITION", ""))
     # the GPU lane for benchmarks with `gpus > 0` (evals + author launches);
     # empty = this deployment cannot place GPU jobs
-    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("--gpu-partition", default=os.environ.get("OUTERLOOP_GPU_PARTITION", ""))
+    parser.add_argument("--gpu-account", default=os.environ.get("OUTERLOOP_GPU_ACCOUNT", ""))
     parser.add_argument(
         "--uncontained",
         action="store_true",
         help="run WITHOUT a container (dev only: sessions can then read "
         "same-user files, including credential files)",
     )
-    parser.add_argument("--claude-bin", default=os.path.expanduser("~/.local/bin/claude"))
+    parser.add_argument(
+        "--claude-bin",
+        default=default_binary("claude"),
+        help="host claude binary for the claude author (OUTERLOOP_CLAUDE_BIN, which init records)",
+    )
     parser.add_argument(
         "--codex-bin",
-        default=os.path.expanduser(
-            os.environ.get("AUTORESEARCH_CODEX_BIN") or "~/.local/bin/codex"
-        ),
+        default=default_binary("codex"),
         help="host codex binary for the codex author; bind-mounted into apptainer "
         "(must be an absolute path).",
     )
     parser.add_argument(
-        "--model", default=os.environ.get("AUTORESEARCH_AUTHOR_MODEL") or "claude-opus-5"
+        "--model", default=os.environ.get("OUTERLOOP_AUTHOR_MODEL") or "claude-opus-5"
     )
     parser.add_argument(
         "--author-backend",
         choices=("claude", "codex"),
-        default=os.environ.get("AUTORESEARCH_AUTHOR_BACKEND") or "claude",
+        default=os.environ.get("OUTERLOOP_AUTHOR_BACKEND") or "claude",
         help="agent backend for the author/editor role (config-driven: default "
-        "from AUTORESEARCH_AUTHOR_BACKEND). codex runs contained (apptainer + "
+        "from OUTERLOOP_AUTHOR_BACKEND). codex runs contained (apptainer + "
         "--sandbox danger-full-access) and REQUIRES --image and a codex/openai "
         "--model (e.g. gpt-5.6-terra).",
     )
@@ -3225,7 +3450,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",
     )
@@ -3233,7 +3458,7 @@ def main() -> int:
         "--key-file",
         default="",
         help="author key file; default resolves per backend (config-driven): "
-        "AUTORESEARCH_CLAUDE_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("--issue", type=int, default=0)
     parser.add_argument(
@@ -3262,12 +3487,11 @@ def main() -> int:
     # and re-enter the decision. The wake job the WakeDispatcher submits runs
     # exactly this.
     if args.resume:
-        placed = bool(args.account and args.partition) or local_mode()
-        if not (placed and args.image and Path(args.image).is_file()):
+        if not (args.image and Path(args.image).is_file()):
             parser.error(
-                "--resume needs the cluster triple (--account/--partition/--image) "
-                "to rebuild the dispatched measurer (local compute waives the "
-                "account/partition pair, never the image)"
+                "--resume needs --image to rebuild the dispatched measurer "
+                "(account and partition are optional: empty ones use Slurm's "
+                "defaults, and local compute has no placement)"
             )
         from outerloop.runstate import load_record
 
@@ -3432,13 +3656,12 @@ def main() -> int:
     except ValueError as exc:
         parser.error(str(exc))
 
-    # Dispatched measurement needs the full cluster triple AND a real image
-    # file to bind against; missing any, the climb measures inline (the tick
-    # sets these on the climb job's env, a bare CLI run leaves them empty).
+    # Dispatched measurement needs a real image file to bind against; without
+    # one the climb measures inline. Account and partition are optional: empty
+    # ones use Slurm's defaults (the tick sets them on the climb job's env from
+    # the chain's), and local compute has no placement.
     dispatch: DispatchSettings | None = None
-    if (bool(args.account and args.partition) or local_mode()) and (
-        args.image and Path(args.image).is_file()
-    ):
+    if args.image and Path(args.image).is_file():
         dispatch = _dispatch_settings(args)
     try:
         try: