outerloop-science 0.1.0.dev2__py3-none-any.whl → 0.1.0.dev4__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
@@ -25,9 +26,9 @@ from functools import partial
 from pathlib import Path
 from typing import Any, cast
 
-from outerloop.appauth import resolve_bot_auth
+from outerloop.appauth import add_credential_args, 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, 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
@@ -186,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`."""
@@ -206,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 ""
 
 
@@ -425,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,
     }
@@ -452,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
@@ -586,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,
@@ -593,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
 ):
@@ -605,45 +677,42 @@ def _make_launcher(
     partially-submitted batch is reaped rather than orphaned. `gpus` is the
     benchmark's: an author's experiments run on the same lane as its evals."""
     account, partition = dispatch.placement(gpus)
-    # under launch admission a GPU launch enters the queue held; the tick
-    # releases it when the user's GPUs fit under the cap (tick.service_admission)
-    from outerloop.tick import max_launch_gpus_from_env
-
-    hold = gpus > 0 and not local_mode() and max_launch_gpus_from_env() > 0
 
     def launcher(sha: str, request: SyscallRequest) -> str:
-        from dataclasses import replace as _replace
-
         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,
-                    )
-                    spec = eval_job_spec(
-                        script,
-                        job_name=f"{run_id}-launch-{job_name}",
-                        account=account,
-                        partition=partition,
-                        eval_minutes=launch.minutes,
-                        gpus=gpus,
-                    )
-                    ids.append(dispatch.compute.submit(_replace(spec, hold=hold)))
+                # 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 —
@@ -661,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,
@@ -713,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))
@@ -776,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)
     )
@@ -786,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", "")),
@@ -804,9 +916,34 @@ 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}"
+    # A research line whose base moved while it slept RE-PINS to the fresh base
+    # and is told to merge it: the agent does the merge (mirroring the in-review
+    # conflict wake, followup.py), the kernel only fetches and re-pins. Re-pinning
+    # base_sha to the fresh head is what makes the gate baseline and the scope
+    # base the CURRENT base (like followup's base_sha_at_fetch), so a sibling's
+    # merged work is never credited to this line and a forbidden conflict
+    # resolution (differing from the fresh base) is still scope-checked. Non-line
+    # runs and an unmoved base are untouched.
+    if _line_ref_for(bench, config.agent_id):
+        fresh_base = _line_base_advanced(ws, base_branch, base_sha)
+        if fresh_base:
+            digest = _reintegration_digest(ws, base_sha, fresh_base)
+            base_sha = fresh_base
+            wake_text = (
+                REINTEGRATE_PROMPT.format(base_branch=base_branch, digest=digest) + wake_text
+            )
     _best_effort(
         "budget refresh",
         lambda: write_budget(
@@ -829,7 +966,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
 
@@ -850,6 +989,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
@@ -873,6 +1013,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,
@@ -937,6 +1078,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
@@ -948,12 +1115,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."""
@@ -966,7 +1135,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
@@ -976,7 +1149,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)
@@ -985,21 +1160,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)
 
@@ -1123,8 +1312,61 @@ def _line_ref_for(bench: Benchmark | None, agent_id: str) -> str:
     return f"agents/{agent_id}"
 
 
+# The base moved under a line while it slept: rather than the kernel doing a
+# git merge (which mishandles the agent's in-flight tree, its conflicts, and
+# the scope gate), the wake mirrors the in-review conflict wake — fetch the
+# fresh base into the workspace and TELL THE AGENT to merge it. The agent has
+# git and already resolves the run-start merge as its first task; only the
+# credential-bearing fetch/push are the kernel's. No commit text goes in the
+# prompt (no cross-agent prompt-injection surface); the agent reads what
+# landed from git itself.
+REINTEGRATE_PROMPT = (
+    "# The base moved while you were asleep\n"
+    "`origin/{base_branch}` advanced since your last run and is fetched into "
+    "your workspace. What landed:\n{digest}\n"
+    "Merge it into your line and resolve any conflicts honestly, then decide "
+    "what to re-run given what landed — if a sibling took your direction "
+    "further, pivot or say so plainly rather than pushing on. Your change is "
+    "measured against the current base.\n\n"
+)
+
+
+def _reintegration_digest(ws: Workspace, base_sha: str, fresh_head: str) -> str:
+    """A short 'what landed' list: the subjects of the commits merged into the
+    base since this line's base, newest first, capped. These are MERGED commits
+    — vetted by the human-merge gate — so they are context, not untrusted input;
+    the agent also has them in git to read in full."""
+    try:
+        out = ws.git("log", "--no-merges", "--format=%s", f"{base_sha}..{fresh_head}")
+    except Exception:
+        return "  (recent changes on the base; see `git log`)"
+    subjects = [ln.strip() for ln in out.splitlines() if ln.strip()][:12]
+    return "\n".join(f"  - {s}" for s in subjects) or "  (a merge on the base; see `git log`)"
+
+
+def _line_base_advanced(ws: Workspace, base_branch: str, base_sha: str) -> str:
+    """Fetch `origin/<base_branch>` and return its head when it has advanced
+    past the line's pinned base, else "". The fetch doubles as making the
+    fresh base available for the agent to merge and refreshes the origin refs
+    the scope/measure path pairs against. Best-effort: any git failure returns
+    "" and the wake proceeds exactly as today."""
+    try:
+        ws.fetch_origin()
+        new = ws.git("rev-parse", f"refs/remotes/origin/{base_branch}").strip()
+        merge_base = ws.git("merge-base", new, base_sha).strip()
+        return new if new and merge_base != new else ""
+    except Exception as exc:
+        log.warning("base-moved check failed (%s); wake proceeds unchanged", type(exc).__name__)
+        return ""
+
+
 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
@@ -1167,7 +1409,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
@@ -1176,10 +1418,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",
@@ -1239,7 +1478,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
@@ -1259,10 +1500,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,
@@ -1277,10 +1515,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",
@@ -1466,12 +1701,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
@@ -1643,11 +1879,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
@@ -1682,7 +1923,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
@@ -1741,7 +1994,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,
@@ -1888,6 +2148,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):
@@ -1955,18 +2216,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}"
@@ -2264,6 +2530,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).
@@ -2287,6 +2554,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)
@@ -2299,10 +2570,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",
@@ -2432,7 +2700,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.
@@ -2496,7 +2764,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",
@@ -2639,6 +2909,7 @@ def live_attempt(
                 config.bot_login,
                 created[:10],
                 exclude=LINE_MEMORY_PATHS if lines_active else (),
+                secrets=secrets,
             )
             if panel_lenses
             else None
@@ -2672,12 +2943,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
@@ -2722,6 +2997,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:
@@ -2786,6 +3066,7 @@ def live_attempt(
                 run_id,
                 "attempt-error",
                 secrets,
+                bot_login=config.bot_login,
             )
         failed = RunRecord(
             **{
@@ -2843,7 +3124,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
@@ -2895,10 +3176,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)})"
@@ -2907,7 +3185,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}"
@@ -3022,7 +3304,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,
@@ -3115,7 +3397,6 @@ def arm_sigterm_containment() -> None:
 def main() -> int:
     import argparse
     import os
-    import time
     from datetime import UTC, datetime
 
     arm_sigterm_containment()
@@ -3230,13 +3511,7 @@ def main() -> int:
         default=120.0,
         help="how long before the walltime the self-deadline fires (floor 60)",
     )
-    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="",