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

outerloop/dispatch.py

@@ -36,8 +36,14 @@ from pathlib import Path
 from uuid import uuid4
 
 from outerloop.compute import JobSpec
-from outerloop.github import SAFE_GIT_FLAGS, GitError, Workspace, ensure_regular_git_dir
-from outerloop.orchestrator import EvalError, _metric_from_output, managed_eval_env
+from outerloop.github import (
+    SAFE_GIT_FLAGS,
+    GitError,
+    Workspace,
+    ensure_regular_git_dir,
+    git_identity,
+)
+from outerloop.orchestrator import EvalError, managed_eval_env, metric_from_output
 
 log = logging.getLogger(__name__)
 
@@ -94,7 +100,11 @@ class Snapshot:
 
 
 def snapshot_tree(
-    ws: Workspace, base_sha: str, exclude: tuple[str, ...] = (), force: tuple[str, ...] = ()
+    ws: Workspace,
+    base_sha: str,
+    exclude: tuple[str, ...] = (),
+    force: tuple[str, ...] = (),
+    author: str = "",
 ) -> Snapshot:
     """Snapshot the workspace's current CONTENT as a commit parented on
     `base_sha`, without touching the working index, and retain it under a
@@ -105,7 +115,8 @@ def snapshot_tree(
     keeps it (docs/design/research-lines.md). `force` adds those paths even
     when the target's ignore rules match them — the notebook seal uses it so
     a .gitignore entry cannot silently discard session memory; callers pass
-    only paths that exist.
+    only paths that exist. `author` is the bot login the seal commit is
+    made as (empty: OUTERLOOP_BOT_LOGIN).
     """
     # the snapshot writes an index, a tree, a commit, and a ref into this
     # repository: a session-reshaped .git is refused first, like every other
@@ -163,10 +174,7 @@ def snapshot_tree(
         commit = run(
             [
                 *git,
-                "-c",
-                "user.name=dispatch",
-                "-c",
-                "user.email=dispatch@localhost",
+                *git_identity(author),
                 "commit-tree",
                 tree,
                 "-p",
@@ -205,6 +213,7 @@ def _filter_neutral_env(base_git: list[str], env: dict[str, str]) -> dict[str, s
         capture_output=True,
         text=True,
         timeout=30,
+        check=False,
     )
     # -z: NUL-separated records, each "key\nvalue" — so a value containing a
     # newline can never masquerade as a second record.
@@ -281,9 +290,22 @@ def write_eval_job(
     artifacts: tuple[str, ...] = (),
     artifact_max_bytes: int = 0,
     gpus: int = 0,
+    array: int = 1,
+    seed_cache: Path | None = None,
 ) -> Path:
     """Write the orchestrator-authored job script for one dispatched eval.
 
+    `seed_cache` names the kernel-warmed seed for this target
+    (docs/design/eval-cache.md): the job copies its contents into its own
+    scratch cache before `uv` runs — a copy, never a bind or a hardlink, so the
+    job's cache is its own and the seed is never written; a missing seed or a
+    failed copy costs a download, never the eval.
+
+    `array` > 1 writes ONE script for a Slurm job array: each task derives its
+    own job dir `eval-<name>.<k>` from SLURM_ARRAY_TASK_ID (SWEEP_INDEX under a
+    local run) and sees the index as SWEEP_INDEX; the task dirs are created
+    and cleared here, the script lives under `eval-<name>/`.
+
     `gpus` > 0 adds `--nv` to the jail so the job's allocated GPUs (the
     JobSpec requests them) are visible inside the container; nothing else
     about the containment changes.
@@ -310,13 +332,16 @@ def write_eval_job(
     """
     ev = run_dir / f"eval-{name}"
     ev.mkdir(parents=True, exist_ok=True)
-    # a resubmitted eval must never be read as its predecessor: every prior
-    # artifact — including a leftover extracted tree — goes before submission
-    for stale in ("exit-code", "stdout", "stderr", "setup.log", "submitted", "artifacts.log"):
-        (ev / stale).unlink(missing_ok=True)
-    shutil.rmtree(ev / "tree", ignore_errors=True)
-    shutil.rmtree(ev / "artifacts", ignore_errors=True)
-    (ev / "command.txt").write_text(command)
+    task_dirs = [run_dir / f"eval-{name}.{k}" for k in range(array)] if array > 1 else [ev]
+    for task_dir in task_dirs:
+        task_dir.mkdir(parents=True, exist_ok=True)
+        # a resubmitted eval must never be read as its predecessor: every prior
+        # artifact — including a leftover extracted tree — goes before submission
+        for stale in ("exit-code", "stdout", "stderr", "setup.log", "submitted", "artifacts.log"):
+            (task_dir / stale).unlink(missing_ok=True)
+        shutil.rmtree(task_dir / "tree", ignore_errors=True)
+        shutil.rmtree(task_dir / "artifacts", ignore_errors=True)
+        (task_dir / "command.txt").write_text(command)
     # extra_env matches the in-job evaluator's contract: managed keys (HOME,
     # UV_*, PATH...) are DROPPED, never allowed to override the isolation, and
     # keys must be shell-identifier shaped (they are exported unquoted).
@@ -330,10 +355,20 @@ def write_eval_job(
     # as the snapshot, injected as GIT_CONFIG_* env (robust to '=' in a driver
     # name, unlike -c) so a smudge filter cannot execute during checkout
     neutral = _filter_neutral_env(["git", "-C", str(repo_root), *SAFE_GIT_FLAGS], {})
+    if array > 1:
+        # the task picks its own job dir; under Slurm the index is the array
+        # task id, under a local run the caller exports SWEEP_INDEX
+        ev_lines = [
+            'TASK="${SLURM_ARRAY_TASK_ID:-${SWEEP_INDEX:-0}}"',
+            f'EV={shlex.quote(str(ev))}."$TASK"',
+            'export SWEEP_INDEX="$TASK" APPTAINERENV_SWEEP_INDEX="$TASK"',
+        ]
+    else:
+        ev_lines = [f"EV={shlex.quote(str(ev))}"]
     lines = [
         "#!/bin/sh",
         "set -u",
-        f"EV={shlex.quote(str(ev))}",
+        *ev_lines,
         f"REPO={shlex.quote(str(repo_root))}",
         # the extracted tree lives on NODE-LOCAL scratch, not the shared run
         # dir: it dies with the job (nothing to reap on the shared FS), and
@@ -361,6 +396,11 @@ def write_eval_job(
     ]
     for k, v in neutral.items():
         lines.append(f"export {k}={shlex.quote(v)}")
+    if seed_cache is not None:
+        q = shlex.quote(str(seed_cache))
+        lines.append(
+            f'if [ -d {q} ]; then cp -a {q}/. "$SCRATCH/cache"/ 2>> "$EV/setup.log" || true; fi'
+        )
     lines += [
         # Materialize the snapshot by CHECKOUT, not `git archive`: a checkout
         # reproduces content faithfully — INCLUDING .gitattributes — and does
@@ -478,6 +518,8 @@ def eval_job_spec(
     cpus: int = 4,
     mem: str = "8G",
     gpus: int = 0,
+    nice: int = 0,
+    array: str = "",
 ) -> JobSpec:
     """The JobSpec for one dispatched eval: the hint CLAMPED to our ceiling
     plus setup slack — a contract value above EVAL_JOB_MINUTES_CEILING must
@@ -486,7 +528,8 @@ def eval_job_spec(
     the GPU lane (DispatchSettings.placement) when it is nonzero, and the
     job is sized for it: a GPU eval gets at least EVAL_CPUS_PER_GPU cores
     and EVAL_MEM_GB_PER_GPU GB per GPU (a training eval's data loading and
-    torch.compile workers do not fit the CPU eval's 4 cores / 8 GB)."""
+    torch.compile workers do not fit the CPU eval's 4 cores / 8 GB). `nice`
+    lowers the job's priority below the kernel's evals (the launcher sets it)."""
     if gpus > 0:
         cpus = max(cpus, EVAL_CPUS_PER_GPU * gpus)
         given = _mem_gb(mem)
@@ -503,6 +546,8 @@ def eval_job_spec(
         cpus=cpus,
         mem=mem,
         gpus=gpus,
+        nice=nice,
+        array=array,
     )
 
 
@@ -541,7 +586,7 @@ def read_eval_result(run_dir: Path, name: str, metric: str) -> float:
         with contextlib.suppress(OSError, ValueError):
             tail = (ev / "stderr").read_text(errors="replace")[-300:]
         raise EvalError(f"dispatched eval {name} failed ({code}): {tail}")
-    value = _metric_from_output(stdout, metric)
+    value = metric_from_output(stdout, metric)
     if value is None:
         raise EvalError(f"dispatched eval {name}: no readable {metric!r} in output")
     if not math.isfinite(value):

outerloop/evalcache.py

@@ -0,0 +1,147 @@
+"""The seed cache: one uv cache per target, warmed by the kernel on the tick
+host and copied into each job's own scratch cache before `uv` runs there
+(docs/design/eval-cache.md). Jobs never write shared state: the warmer
+downloads and unpacks wheels only (`--no-build`, so no build backend of the
+target's ever runs here), and a job's copy is its own from the first byte."""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import os
+import shutil
+import subprocess
+import tempfile
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+log = logging.getLogger(__name__)
+
+SEED_DIR = "eval-cache"
+LOCK_HASH = ".lockfile-sha256"
+# what uv sync needs to resolve a locked project without its sources
+WARM_FILES = ("pyproject.toml", "uv.lock")
+# the interpreter the eval jobs run under (the agent image's); wheels are
+# picked for it, and the tick host's uv fetches it when it has none
+EVAL_PYTHON = "3.12"
+WARM_TIMEOUT_S = 30 * 60
+# what uv needs to download wheels and nothing more: the tick host's
+# environment holds credentials (token providers, key paths) that an
+# uncontained download process has no business seeing
+WARM_ENV_KEYS = (
+    "PATH",
+    "HOME",
+    "LANG",
+    "LC_ALL",
+    "TMPDIR",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "NO_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "no_proxy",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+    "REQUESTS_CA_BUNDLE",
+)
+
+Runner = Callable[..., Any]
+
+
+def seed_dir(root: Path, target: str) -> Path:
+    """Where a target's seed lives under the state root."""
+    return root / SEED_DIR / target.replace("/", "__")
+
+
+def lockfile_hash(files: dict[str, str]) -> str:
+    h = hashlib.sha256()
+    for name in sorted(files):
+        h.update(name.encode())
+        h.update(b"\0")
+        h.update(files[name].encode())
+        h.update(b"\0")
+    return h.hexdigest()
+
+
+def warm(
+    root: Path,
+    target: str,
+    github: Any,
+    ref: str,
+    *,
+    runner: Runner = subprocess.run,
+    uv: str | None = None,
+    python: str = EVAL_PYTHON,
+) -> str:
+    """Warm the target's seed from its lockfile at `ref`, when the lockfile
+    changed since the last warm. Fetches `pyproject.toml` and `uv.lock` only
+    (never the sources), and runs `uv sync --frozen --no-install-project
+    --no-build --all-extras` into a throwaway environment with the seed as
+    uv's cache. Returns one word on what happened, for the tick's report:
+    "warmed", "unchanged", or "skipped: ..." / "failed: ..." with the reason.
+    A failure leaves the seed as it was and the hash unrecorded, so the next
+    tick tries again."""
+    files: dict[str, str] = {}
+    for name in WARM_FILES:
+        text = github.get_file_content(target, name, ref)
+        if text is None:
+            return f"skipped: no {name} at {ref}"
+        files[name] = text
+    digest = lockfile_hash(files)
+    seed = seed_dir(root, target)
+    marker = seed / LOCK_HASH
+    try:
+        if marker.read_text().strip() == digest:
+            return "unchanged"
+    except OSError:
+        pass
+    uv = uv or shutil.which("uv")
+    if not uv:
+        return "skipped: uv is not on the tick host's PATH"
+    # warm into a fresh directory beside the seed and swap it in whole: the
+    # seed then holds exactly this lockfile's wheels (nothing accumulates
+    # across lockfile changes), and a job copying mid-swap fails its
+    # best-effort copy rather than seeing a half-written cache
+    seed.parent.mkdir(parents=True, exist_ok=True)
+    fresh = seed.parent / f".{seed.name}.warm-{digest[:12]}"
+    shutil.rmtree(fresh, ignore_errors=True)
+    fresh.mkdir()
+    with tempfile.TemporaryDirectory(prefix="outerloop-warm-") as tmp:
+        for name, text in files.items():
+            (Path(tmp) / name).write_text(text)
+        env = {k: os.environ[k] for k in WARM_ENV_KEYS if k in os.environ}
+        env.update(
+            UV_CACHE_DIR=str(fresh),
+            UV_PROJECT_ENVIRONMENT=str(Path(tmp) / ".venv"),
+            UV_LINK_MODE="copy",
+        )
+        argv = [
+            uv,
+            "sync",
+            "--frozen",
+            "--no-install-project",
+            "--no-build",
+            "--all-extras",
+            "--python",
+            python,
+        ]
+        try:
+            proc = runner(
+                argv, cwd=tmp, env=env, capture_output=True, text=True, timeout=WARM_TIMEOUT_S
+            )
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            shutil.rmtree(fresh, ignore_errors=True)
+            return f"failed: {type(exc).__name__}: {exc}"
+    if proc.returncode != 0:
+        shutil.rmtree(fresh, ignore_errors=True)
+        tail = (proc.stderr or "").strip().splitlines()[-3:]
+        return f"failed: uv sync exited {proc.returncode}: {' | '.join(tail)}"
+    (fresh / LOCK_HASH).write_text(digest)
+    old = seed.parent / f".{seed.name}.old"
+    shutil.rmtree(old, ignore_errors=True)
+    if seed.exists():
+        os.replace(seed, old)
+    os.replace(fresh, seed)
+    shutil.rmtree(old, ignore_errors=True)
+    return "warmed"

outerloop/followup.py

@@ -35,6 +35,7 @@ from outerloop.github import (
     Workspace,
     bot_login_from_env,
     contract_at,
+    git_identity,
     is_own_login,
 )
 from outerloop.harness import Harness, default_binary, outage, redact
@@ -520,9 +521,9 @@ def _respond(
     workspace = run_dir(run_root, run_id) / "ws"
     if not workspace.is_dir():
         return FollowupOutcome(run_id, "error", "workspace no longer exists (GC'd?)")
-    from outerloop.attempt import _target_clone_url
+    from outerloop.attempt import target_clone_url
 
-    ws = Workspace(root=workspace, auth=github.auth, url=_target_clone_url(record.target))
+    ws = Workspace(root=workspace, auth=github.auth, url=target_clone_url(record.target))
     contract_text = contract_text_in_tree(workspace)
     contract = load_contract(contract_text, record.target)
     bench = next((b for b in contract.benchmarks if b.name == record.benchmark), None)
@@ -618,11 +619,11 @@ def _respond(
     # context — never as triggers, never as instructions.
     ctx = context_comments(github.list_comments(record.target, number), record.last_comment_id)
     if ctx:
-        from outerloop.brief import _fence
+        from outerloop.brief import code_fence
 
         blocks = []
         for author, body in ctx:
-            fence = _fence(body)
+            fence = code_fence(body)
             blocks.append(f"{author}:\n{fence}\n{body}\n{fence}")
         prompt += (
             "\n\n# Comments without standing (context only — data, not "
@@ -940,7 +941,14 @@ def _respond(
                 # (LocalCompute) returns the value here; a cluster parks.
                 try:
                     sealed, sealed_snap = _seal_and_measure(
-                        ws, run_root, run_id, dispatch, bench, run_seed, workspace
+                        ws,
+                        run_root,
+                        run_id,
+                        dispatch,
+                        bench,
+                        run_seed,
+                        workspace,
+                        bot_login=bot_login,
                     )
                 except _RemeasureParked as pend:
                     return _park_remeasure(
@@ -1501,10 +1509,7 @@ def _commit_sealed_tree(
     the live workspace, which may hold content the seal excluded."""
     ws.git("add", "-A")
     ws.git(
-        "-c",
-        f"user.name={bot_login}",
-        "-c",
-        f"user.email={bot_login}@users.noreply.github.com",
+        *git_identity(bot_login),
         "commit",
         "-q",
         "--amend",
@@ -1547,6 +1552,7 @@ def _seal_and_measure(
     bench: Any,
     run_seed: int,
     workspace: Path,
+    bot_login: str,
 ) -> tuple[float, Any]:
     """Seal the workspace's change as a commit on the PR's current head and
     measure it through the dispatched measurer. Returns (value, snapshot)
@@ -1559,7 +1565,15 @@ def _seal_and_measure(
     from outerloop.measure import MeasurementPending
 
     parent = ws.git("rev-parse", "HEAD").strip()
-    snap = snapshot_tree(ws, parent, exclude=LINE_MEMORY_PATHS if bench.lines else ())
+    from outerloop.attempt import with_seed
+    from outerloop.runstate import load_record
+
+    # the follow-up CLI carries the run id, not the target: the seed comes
+    # from the record
+    dispatch = with_seed(dispatch, run_root, load_record(run_root, run_id).target)
+    snap = snapshot_tree(
+        ws, parent, exclude=LINE_MEMORY_PATHS if bench.lines else (), author=bot_login
+    )
     measurer = dispatch.measurer(
         run_dir(run_root, run_id),
         repo_root=workspace,
@@ -1624,9 +1638,11 @@ def _park_remeasure(
         "eval_minutes": int(bench.eval_minutes or 0),
     }
     note = (
-        "\n\n_(A code change was made; its re-measure is running on the GPU lane "
-        f"({len(pend.job_ids)} job(s)) — the change is pushed with its number once the "
-        "measurement lands. Comments posted meanwhile are answered after that.)_"
+        "\n\n_(Not pushed yet: the change above is local so far. The changed tree is "
+        f"being re-measured on the GPU lane first ({len(pend.job_ids)} job(s) pending), "
+        "and if the result can be applied the branch is updated with it and its number — "
+        "until then GitHub still shows the previous head, including any conflict. "
+        "Comments posted meanwhile are answered after that.)_"
     )
     stage["reply_note"] = note
     stage["reply_posted"] = False
@@ -1692,9 +1708,9 @@ def _resume_measure(
             "error",
             "a dispatched re-measure is parked but no cluster coordinates were given",
         )
-    from outerloop.attempt import _target_clone_url
+    from outerloop.attempt import target_clone_url
 
-    ws = Workspace(root=workspace, auth=github.auth, url=_target_clone_url(record.target))
+    ws = Workspace(root=workspace, auth=github.auth, url=target_clone_url(record.target))
     # the measurement's contract is the SEALED tree's — what was actually
     # measured — never the live workspace file, which can change during the
     # wait (terra #241 r1)
@@ -1986,7 +2002,11 @@ def main() -> int:
     # the tick passes the effective limit explicitly; this fallback follows
     # the harness ceiling so a bare CLI run is never silently starved
     parser.add_argument("--max-turns", type=int, default=DEFAULT_MAX_TURNS)
-    parser.add_argument("--bot-login", default=bot_login_from_env())
+    parser.add_argument(
+        "--bot-login",
+        default=bot_login_from_env(),
+        help="the login the kernel posts as (OUTERLOOP_BOT_LOGIN); required",
+    )
     parser.add_argument(
         "--job-minutes",
         type=int,
@@ -2025,6 +2045,8 @@ def main() -> int:
         "the read is skipped and said so; the author's budget is never the panel's)",
     )
     args = parser.parse_args()
+    if not args.bot_login.strip():
+        parser.error("--bot-login / OUTERLOOP_BOT_LOGIN is required (no default identity, #298)")
     logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
     if not args.image and not args.uncontained:
         parser.error("--image is required (or pass --uncontained explicitly, dev only)")

outerloop/github.py

@@ -37,18 +37,29 @@ from typing import Any, Protocol
 from outerloop.contract import CONTRACT_NAMES, find_contract
 from outerloop.markers import legacy_marker, marker
 
-DEFAULT_BOT_LOGIN = "agentic-learning-bot"
 
-
-def bot_login_from_env(default: str = DEFAULT_BOT_LOGIN) -> str:
+def bot_login_from_env(default: str = "") -> str:
     """The login the kernel posts and pushes as — the bot ACCOUNT under a PAT,
     the App's `<slug>[bot]` under App auth (docs/design/github-app-auth.md).
     `OUTERLOOP_BOT_LOGIN` sets it for every role at once (the tick exports
     it, jobs inherit it); every own-comment filter, alarm-issue lookup and
-    intake-claim scan keys on this string, so it must follow the credential."""
+    intake-claim scan keys on this string, so it must follow the credential.
+    There is no built-in default (#298): a wrong identity hides the kernel's
+    own PRs from it, so an unset login fails closed — the tick refuses to
+    service a target without one, and `init` records it on both auth paths."""
     return os.environ.get("OUTERLOOP_BOT_LOGIN", "").strip() or default
 
 
+def git_identity(login: str = "") -> tuple[str, ...]:
+    """`git -c` arguments that make a commit the kernel's: the bot login and
+    its GitHub noreply address, so GitHub attributes the commit to the App or
+    bot account like every other kernel write. One identity for every kernel
+    commit — seals, line merges, ledger commits alike. An empty login takes
+    OUTERLOOP_BOT_LOGIN."""
+    login = login or bot_login_from_env()
+    return ("-c", f"user.name={login}", "-c", f"user.email={login}@users.noreply.github.com")
+
+
 def bot_aliases_from_env() -> tuple[str, ...]:
     """Former logins the kernel posted as (comma-separated
     `OUTERLOOP_BOT_ALIASES`). Every issue, claim, alarm and PR created
@@ -271,9 +282,13 @@ class GitHubClient:
         path = f"/repos/{urllib.parse.quote(repo)}/issues/{number}"
         return self._expect_dict(self._request("GET", path), path)
 
-    def list_open_issues(self, repo: str, max_pages: int = 3) -> list[dict[str, Any]]:
-        """Open issues (PRs excluded — the issues API mixes them in)."""
-        items = self._paginate(f"/repos/{urllib.parse.quote(repo)}/issues", max_pages)
+    def list_open_issues(
+        self, repo: str, max_pages: int = 3, creator: str = ""
+    ) -> list[dict[str, Any]]:
+        """Open issues (PRs excluded — the issues API mixes them in); `creator`
+        narrows them to one author's, server-side."""
+        query = urllib.parse.urlencode({"creator": creator}) if creator else ""
+        items = self._paginate(f"/repos/{urllib.parse.quote(repo)}/issues", max_pages, query)
         return [i for i in items if "pull_request" not in i]
 
     def create_pull(
@@ -676,10 +691,11 @@ class GitHubClient:
             f"/repos/{urllib.parse.quote(repo)}/pulls/{number}/comments", max_pages
         )
 
-    def _paginate(self, base_path: str, max_pages: int) -> list[dict[str, Any]]:
+    def _paginate(self, base_path: str, max_pages: int, query: str = "") -> list[dict[str, Any]]:
         items: list[dict[str, Any]] = []
+        extra = f"&{query}" if query else ""
         for page in range(1, max_pages + 1):
-            data = self._request("GET", f"{base_path}?per_page=100&page={page}")
+            data = self._request("GET", f"{base_path}?per_page=100&page={page}{extra}")
             if not isinstance(data, list) or not data:
                 break
             items.extend(item for item in data if isinstance(item, dict))
@@ -752,6 +768,17 @@ class GitHubClient:
         )
         return int(data.get("number", 0)) if isinstance(data, dict) else 0
 
+    def update_issue(self, repo: str, number: int, body: str) -> None:
+        """Replace an issue's body (the rolling maintenance digest)."""
+        if self.dry_run:
+            log.info("[dry-run] update issue %s#%s (%d chars)", repo, number, len(body))
+            return
+        self._request(
+            "PATCH",
+            f"/repos/{urllib.parse.quote(repo)}/issues/{number}",
+            {"body": body},
+        )
+
     def close_issue(self, repo: str, number: int) -> None:
         if self.dry_run:
             log.info("[dry-run] close issue %s#%s", repo, number)
@@ -1282,6 +1309,7 @@ def _filter_override_pairs(root: Path | None) -> list[tuple[str, str]]:
         },
         capture_output=True,
         timeout=30,
+        check=False,
     )
     # BYTES + surrogateescape, never text=True: the config is session-written,
     # so a non-UTF-8 byte in a value must not crash the git call — and the
@@ -1429,10 +1457,7 @@ class Workspace:
                 self.git("reset")
                 raise ForbiddenPathError(f"commit touches forbidden paths: {sorted(violations)}")
         self.git(
-            "-c",
-            f"user.name={author}",
-            "-c",
-            f"user.email={author}@users.noreply.github.com",
+            *git_identity(author),
             "commit",
             "-m",
             message,

outerloop/harness.py

@@ -952,6 +952,7 @@ class CodexHarness:
                 capture_output=True,
                 text=True,
                 timeout=60,
+                check=False,
             )
         except OSError as exc:
             log.warning("could not spawn codex login: %s", exc)
@@ -1440,21 +1441,3 @@ class HermesHarness:
             prior_turns.append({"role": "assistant", "text": redact(result.final_text, secrets)})
             _save_resume_transcript(session_home, session_id, prior_turns)
         return replace(result, session_id=session_id)
-
-
-@dataclass
-class FakeHarness:
-    """Deterministic in-process harness for tests and dry runs."""
-
-    result: SessionResult
-    script: Any = None  # optional callable(brief_text, workspace) for side effects
-    calls: list[tuple[str, str, str | None]] = field(default_factory=list)
-    supports_resume: bool = True  # a field so tests can exercise the no-resume path
-
-    def run(
-        self, brief_text: str, workspace: Path, resume_session_id: str | None = None
-    ) -> SessionResult:
-        self.calls.append((brief_text, str(workspace), resume_session_id))
-        if self.script is not None:
-            self.script(brief_text, workspace)
-        return self.result

outerloop/housekeeping.py

@@ -30,7 +30,7 @@ import time
 from dataclasses import replace
 from pathlib import Path
 
-from outerloop.runstate import ENDED, RunRecord, list_runs, load_record, run_dir, save_record
+from outerloop.runstate import ENDED, RunRecord, load_record, run_dir, save_record
 
 log = logging.getLogger(__name__)
 
@@ -38,22 +38,6 @@ WORKSPACE_DIRS = ("ws", "ws-home")
 DEFAULT_SHED_GRACE_S = 24 * 3600.0
 
 
-def shed_candidates(root: Path, now: float, grace_s: float, force: bool) -> list[RunRecord]:
-    """Ended runs whose workspaces may go now, oldest ending first. With
-    `force` (the disk is failing) the grace period does not apply."""
-    due: list[RunRecord] = []
-    for record in list_runs(root):
-        if record.state != ENDED or record.workspace_shed:
-            continue
-        if not force and now - record.updated < grace_s:
-            continue
-        if not any((run_dir(root, record.run_id) / d).exists() for d in WORKSPACE_DIRS):
-            continue
-        due.append(record)
-    due.sort(key=lambda r: r.updated)
-    return due
-
-
 def shed_workspace(root: Path, record: RunRecord, now: float) -> bool:
     """Remove the run's `ws` and `ws-home` directories and stamp the record.
     Returns False (and removes nothing) when either is a symlink."""

outerloop/image.py

@@ -190,10 +190,6 @@ def containment_check(*, runner: Callable[..., Any] = subprocess.run) -> str:
     return ""
 
 
-def containment_available() -> bool:
-    return containment_check() == ""
-
-
 def _fmt_mb(n: int) -> str:
     return f"{n / (1 << 20):,.0f} MB"