ctrlrelay 0.19.1__tar.gz → 0.20.0__tar.gz

{ctrlrelay-0.19.1 → ctrlrelay-0.20.0}/CHANGELOG.md

@@ -7,6 +7,53 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.20.0] - 2026-11-04
+
+### Added
+
+- `repos[].steps.plan` (`off`, `on`, `required`; unset is `off`) runs a
+  planning session before the dev pipeline's code session. It changes no
+  files and writes a plan with numbered acceptance criteria, saved under
+  `<paths.contexts>/<owner>-<repo>/plans/issue-<n>.md` (outside the worktree),
+  posted on the issue as the criteria list, and added to the code session's
+  prompt. A vague issue gets one question instead of a pull request. A plan
+  without criteria is a failed plan: `on` reports it and codes without one,
+  `required` fails the run (#220).
+- On the status page, a peer machine's name links to that machine's own
+  page: in the machine strip, in "Who has what" and on a "Needs you" card.
+  The address is the `fleet.peers` entry from this machine's config, cut to
+  `<scheme>://<host>[:port]/`; nothing a peer answers changes it, and an
+  entry with userinfo or a non-http scheme gives plain text (#319).
+
+### Fixed
+
+- A run whose relay process died mid-run (the machine ran out of memory, or
+  the service was stopped) no longer stays `running` for ever. Sessions now
+  record the process running them (`owner_pid`, `owner_run`) and their claim
+  id. When the poller starts, it finds `running` sessions whose process is
+  gone, and in whose worktree no process is still working, and marks them
+  failed, dropping any repo lock they held. A dev or task issue goes back to
+  the next poll unless an open pull request was found for its branch. Where
+  the run had claimed the issue, the relay posts a comment that names the
+  worktree and releases the claim. The relay deletes nothing in the
+  worktree. It detaches the worktree's HEAD, when that can be done safely,
+  so the next run can check the issue's branch out. Rows written by an older
+  version name no process and are left alone (#312).
+- A dev run whose agent session hits its time limit no longer throws away
+  the agent's work. Before the worktree is removed, the files on disk are
+  committed on top of the commit it sits on, and that commit, or the
+  unpushed commits alone, are pushed to a new `wip/issue-<n>-<run id>`
+  branch. The run's own branch is not pushed, no pull request is opened, and
+  the local run branch is kept, since it can hold commits the worktree's
+  HEAD does not reach. The failure comment on the issue names the wip branch
+  and, when it is known, how long the run took. If the work cannot be saved,
+  the worktree is kept on disk and the comment names it. A run with nothing
+  new loses only its worktree. Files the worktree's `.gitignore` ignores are
+  not saved; files that cannot be read are not saved either, and then the
+  worktree is kept and the comment says so. The files are read by a git with
+  a private git dir, index, config and attributes override, so filters,
+  hooks and attributes named by the agent do not take effect (#311).
+
 ## [0.19.1] - 2026-11-03
 
 ### Fixed
@@ -2266,7 +2313,8 @@ pipeline).
   per-phase implementation plans (Phase 0 through Phase 4).
 - `docs/Claude_Code_Project_Guide.md` — project development guide.
 
-[Unreleased]: https://github.com/AInvirion/ctrlrelay/compare/v0.19.1...HEAD
+[Unreleased]: https://github.com/AInvirion/ctrlrelay/compare/v0.20.0...HEAD
+[0.20.0]: https://github.com/AInvirion/ctrlrelay/compare/v0.19.1...v0.20.0
 [0.19.1]: https://github.com/AInvirion/ctrlrelay/compare/v0.19.0...v0.19.1
 [0.19.0]: https://github.com/AInvirion/ctrlrelay/compare/v0.18.0...v0.19.0
 [0.18.0]: https://github.com/AInvirion/ctrlrelay/compare/v0.17.1...v0.18.0

{ctrlrelay-0.19.1 → ctrlrelay-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ctrlrelay
-Version: 0.19.1
+Version: 0.20.0
 Summary: Local-first orchestrator for headless coding agents across multiple GitHub repos
 Project-URL: Homepage, https://github.com/AInvirion/ctrlrelay
 Project-URL: Documentation, https://ainvirion.github.io/ctrlrelay/

{ctrlrelay-0.19.1 → ctrlrelay-0.20.0}/docs/configuration.md

@@ -865,7 +865,8 @@ repos:
 
 ### repos[].steps
 
-The dev pipeline does its work in a fixed order: **code** (the agent run and
+The dev pipeline does its work in a fixed order: **plan** (an optional
+planning session, off unless asked for), **code** (the agent run and
 any questions it asks), **publish** (the relay pushes the branch and opens the
 pull request), **verify** (wait for CI and mergeability, asking the agent to
 fix what fails, up to `max_fix_attempts` rounds) and **review** (the
@@ -893,6 +894,7 @@ repos:
 
 | Step | Accepts | Unset means |
 |---|---|---|
+| `plan` | `off`, `on`, `required` | `off`: no planning session. |
 | `code` | `required` | A failed or crashed agent run stops the run. Same as `required`. |
 | `publish` | `required` | A refused or failed push stops the run (the branch is kept). Same as `required`. |
 | `verify` | `off`, `required` | CI still red after the fix rounds stops the run. CI that is still pending when the wait times out hands the PR over. |
@@ -905,6 +907,28 @@ PR as ready while its CI is red, with no line in the announcement saying so.
 Unknown step names (a typo such as `verfy`) are refused as well. A bare `on`
 or `off` works unquoted.
 
+**`plan: on`** or **`plan: required`** runs one planning session in the
+run's worktree before the code session. It is told to read the issue and the
+repo and change no files, and returns a plan with four headings: `## Change`,
+`## Files`, `## Risks` and `## Acceptance criteria`, a numbered list of items
+that can each be checked by a command or by reading the diff. The relay then:
+
+- saves the plan to `<paths.contexts>/<owner>-<repo>/plans/issue-<n>.md`,
+  outside the worktree, so it is never committed;
+- posts the criteria list as one comment on the issue;
+- adds the plan to the code session's prompt under `## Plan`, telling the
+  agent the criteria are what "done" means.
+
+If the issue is too vague to plan, the planning session asks one question,
+through the same chat loop the code session uses. No code session runs and no
+PR is opened until it is answered; an answer that arrives after the run
+stopped resumes the planning session, then codes with the plan.
+
+A plan with no numbered acceptance criteria is a failed plan, as is a
+planning session that fails or crashes. With `on` the failure is posted on the
+issue and the code session runs without a plan; with `required` the run fails
+and no code session runs.
+
 **`verify: required`** also fails the run when the CI wait times out, before
 or after a fix round. (Checks that cannot be read at all fail the run in every
 mode that waits on CI, not only under `required`.)

{ctrlrelay-0.19.1 → ctrlrelay-0.20.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ctrlrelay"
-version = "0.19.1"
+version = "0.20.0"
 description = "Local-first orchestrator for headless coding agents across multiple GitHub repos"
 readme = "README.md"
 requires-python = ">=3.12"

{ctrlrelay-0.19.1 → ctrlrelay-0.20.0}/src/ctrlrelay/cli.py

@@ -4203,6 +4203,28 @@ def poller_start(
                         skip_initial_persist=True,
                     )
 
+            # Runs whose process died with them (#312): settle them before
+            # the first poll, so the issues they held are taken again by
+            # that poll rather than skipped as already seen.
+            from ctrlrelay.core.orphans import reap_orphaned_sessions
+            reaped = await reap_orphaned_sessions(
+                state_db, poller=poller, github=github, worktree=worktree,
+            )
+            for r in reaped:
+                where = (
+                    f"#{r['issue_number']} in {r['repo']}"
+                    if r["issue_number"] is not None else r["repo"]
+                )
+                kept = (
+                    f" Its worktree is kept at {r['worktree_path']}."
+                    if r["worktree_path"]
+                    and Path(r["worktree_path"]).exists() else ""
+                )
+                console.print(
+                    f"[yellow]Run {r['session_id']} for {where} stopped "
+                    f"when the relay did; marked failed.{kept}[/yellow]"
+                )
+
             try:
                 await github_budget.refresh()
                 await run_poll_loop(

{ctrlrelay-0.19.1 → ctrlrelay-0.20.0}/src/ctrlrelay/core/config.py

@@ -507,6 +507,9 @@ _REPO_NAME_RE = re.compile(r"^[A-Za-z0-9._-]+/[A-Za-z0-9._-]+$")
 # reads this table as well, so a caller that bypasses the config cannot
 # get a mode accepted and ignored.
 DEV_STEP_MODES: dict[str, tuple[str, ...]] = {
+    # ``plan`` (#220) runs before ``code``. Unset is ``off``: a repo that
+    # does not ask for a plan runs exactly as it did before the step.
+    "plan": ("off", "on", "required"),
     "code": ("required",),
     "publish": ("required",),
     "verify": ("off", "required"),
@@ -514,6 +517,7 @@ DEV_STEP_MODES: dict[str, tuple[str, ...]] = {
 }
 
 _STEP_REFUSALS: dict[str, str] = {
+    "plan": "",
     "code": (
         "a dev run without the agent run has nothing to publish"
     ),
@@ -567,7 +571,7 @@ class DevStepsConfig(BaseModel):
     ``verify`` stops it when CI is still red after the fix rounds, but
     hands the pull request over when the CI wait times out; ``review``
     reports a review that did not post and hands the pull request over
-    anyway (``on``).
+    anyway (``on``); ``plan`` does not run (``off``).
 
     Unknown keys are refused, so a typo such as ``verfy: required``
     cannot load as "unset".
@@ -575,12 +579,15 @@ class DevStepsConfig(BaseModel):
 
     model_config = {"extra": "forbid"}
 
+    plan: str | None = None
     code: str | None = None
     publish: str | None = None
     verify: str | None = None
     review: str | None = None
 
-    @field_validator("code", "publish", "verify", "review", mode="before")
+    @field_validator(
+        "plan", "code", "publish", "verify", "review", mode="before"
+    )
     @classmethod
     def _known_mode(cls, v: Any, info: Any) -> str | None:
         return check_dev_step_mode(info.field_name, v)

{ctrlrelay-0.19.1 → ctrlrelay-0.20.0}/src/ctrlrelay/core/dispatcher.py

@@ -133,6 +133,9 @@ class SessionResult:
     stdout: str = ""
     stderr: str = ""
     agent_session_id: str | None = None
+    # The relay killed the agent at its time limit (#311). Set only by the
+    # relay's own timeout path, never parsed from anything the agent wrote.
+    timed_out: bool = False
 
     @property
     def success(self) -> bool:
@@ -352,6 +355,7 @@ class CliAgentAdapter:
                 exit_code=-1,
                 state=None,
                 stderr="Session timed out",
+                timed_out=True,
             )
         except asyncio.CancelledError as e:
             # Scheduler/shutdown cancel: kill the child BEFORE re-raising

ctrlrelay-0.20.0/src/ctrlrelay/core/orphans.py

@@ -0,0 +1,388 @@
+"""Runs whose process died without settling them (#312).
+
+A session's ``sessions`` row is moved off ``running`` only by the process
+running it. When that process dies first (the kernel's out-of-memory
+killer, a ``systemctl stop`` that takes the whole unit, a power cut), the
+row says ``running`` for ever: the status page lists it as running, the
+issue stays in the poller's ``seen_issues`` so nothing looks at it again,
+its claim reads as working, and a repo lock it held can wedge the repo.
+
+:func:`reap_orphaned_sessions` runs once when the poller starts, before
+the first poll, and settles each such row: failed, lock dropped, issue
+handed back to the poller, claim released, worktree kept and named.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+from typing import Any, Callable
+
+from ctrlrelay.core.claims import PROCESS_RUN
+from ctrlrelay.core.obs import get_logger, log_event
+
+_logger = get_logger("core.orphans")
+
+# Pipelines whose issue goes back to the poller when their run died. A
+# secops sweep has no issue; it runs again on its own schedule.
+_ISSUE_PIPELINES = frozenset({"dev", "task"})
+
+
+def _command_line(pid: int) -> list[str] | None:
+    proc = Path("/proc")
+    if proc.is_dir():
+        try:
+            raw = (proc / str(pid) / "cmdline").read_bytes()
+        except OSError:
+            return None
+        return [a.decode("utf-8", "replace") for a in raw.split(b"\0") if a]
+    import subprocess
+    try:
+        out = subprocess.run(
+            ["ps", "-o", "command=", "-p", str(pid)],
+            capture_output=True, text=True, timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if out.returncode != 0:
+        return None
+    return out.stdout.split()
+
+
+def owner_is_alive(pid: int) -> bool:
+    """Whether the process that owns a session may still be running it.
+
+    Errs towards alive, because the mistake in that direction leaves a
+    row as it is today, while the other one fails a live run under its
+    own feet. So: a process that exists and runs ctrlrelay, or whose
+    command line cannot be read, is alive. Gone, or reused by a program
+    that is not ctrlrelay, is dead.
+
+    This process's own pid is dead here. The caller has already kept
+    every row this process wrote, by its run id (``owner_run``), so a row
+    that names this pid with another run id was written by an earlier
+    process whose pid was handed on to this one, as happens to pid 1 in a
+    container on every restart.
+    """
+    if pid <= 0 or pid == os.getpid():
+        return False
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        # Exists, owned by another user: not ours, but not provably
+        # dead either.
+        return True
+    except OSError:
+        return True
+    args = _command_line(pid)
+    if args is None:
+        # Exited between the two checks, or unreadable. A vanished
+        # process reads as `None` too, so look once more.
+        try:
+            os.kill(pid, 0)
+        except ProcessLookupError:
+            return False
+        except OSError:
+            return True
+        return True
+    # The console script, or `python -m ctrlrelay...`. Not a substring
+    # test: the interpreter of a uv tool install lives under a directory
+    # named ctrlrelay, so any Python program run with it would match.
+    for i, arg in enumerate(args):
+        if os.path.basename(arg) == "ctrlrelay":
+            return True
+        if (arg == "ctrlrelay" or arg.startswith("ctrlrelay.")) and (
+            i > 0 and args[i - 1] == "-m"
+        ):
+            return True
+        if arg == "-mctrlrelay" or arg.startswith("-mctrlrelay."):
+            return True
+    return False
+
+
+def worktree_in_use(path: str) -> bool | None:
+    """Whether a live process of this user has its working directory
+    inside ``path``: ``True``, ``False``, or ``None`` when that cannot be
+    told.
+
+    The relay process can die alone (``kill -9``, the OOM killer choosing
+    it) while the agent it started keeps running, because the agent is
+    in the relay's process group, not under it. Such a run is not dead,
+    and settling it would detach the worktree under a live agent and
+    start a second run on the same issue. The agent works in its
+    worktree, as the relay's own user, so such a process there is the
+    sign. Processes of other users are not looked at: an agent never
+    runs as another user, and their working directories are not
+    readable anyway.
+    """
+    try:
+        root = os.path.realpath(path)
+    except OSError:
+        return None
+    prefix = root.rstrip(os.sep) + os.sep
+    uid = os.getuid()
+    proc = Path("/proc")
+    if proc.is_dir():
+        try:
+            entries = [e for e in os.listdir(proc) if e.isdigit()]
+        except OSError:
+            return None
+        # This process is of this user and has a working directory, so a
+        # scan that read none did not work, whatever it returned.
+        read_any = False
+        for pid in entries:
+            try:
+                if os.stat(f"/proc/{pid}").st_uid != uid:
+                    continue
+                cwd = os.readlink(f"/proc/{pid}/cwd")
+                read_any = True
+            except OSError:
+                # Exited while being looked at, or a process of ours that
+                # made itself non-dumpable (systemd --user, ssh-agent).
+                # An agent is neither: its working directory reads,
+                # inside the bwrap sandbox too.
+                continue
+            if cwd == root or cwd.startswith(prefix):
+                return True
+        return False if read_any else None
+    import shutil
+    import subprocess
+    lsof = shutil.which("lsof")
+    if lsof is None:
+        return None
+    try:
+        out = subprocess.run(
+            [lsof, "-w", "-n", "-P", "-a", "-u", str(uid), "-d", "cwd",
+             "-F", "n"],
+            capture_output=True, text=True, timeout=20,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if out.returncode not in (0, 1):
+        return None
+    cwds = [line[1:] for line in out.stdout.splitlines() if line.startswith("n")]
+    if not cwds:
+        # Not even this process's own: lsof did not answer.
+        return None
+    return any(cwd == root or cwd.startswith(prefix) for cwd in cwds)
+
+
+def orphan_reason(row: dict[str, Any], branch: str | None) -> str:
+    """The ``Reason:`` line of the issue comment for a dead run.
+
+    Says only what was checked: where the files are when the worktree was
+    found, and that the branch was freed only when it was.
+    """
+    where = row.get("worktree_path")
+    if where and Path(where).exists():
+        kept = (
+            f"Its worktree is still on that machine at `{where}`"
+            + (f", detached from `{branch}`" if branch else "")
+            + ", and the relay deleted nothing in it."
+        )
+    elif where:
+        kept = f"Its worktree `{where}` was not found on that machine."
+    else:
+        kept = "No worktree was recorded for it."
+    return (
+        "the relay process running it stopped before the run ended "
+        "(for example the machine ran out of memory, or the service was "
+        f"restarted). {kept}"
+    )
+
+
+async def _open_pr_for(github: Any, repo: str, branch: str | None) -> int | None:
+    """The same-repo open pull request for ``branch``, or ``None`` when
+    none was found: there is none, the branch is unknown (no worktree to
+    read it from), or the lookup failed."""
+    if not branch:
+        return None
+    try:
+        prs = await github.list_prs(repo, state="open", head=branch, timeout=30)
+    except asyncio.CancelledError:
+        raise
+    except Exception as e:
+        log_event(
+            _logger, "orphans.pr_lookup_failed", repo=repo, branch=branch,
+            reason=type(e).__name__, error=str(e)[:200],
+        )
+        return None
+    owner, _, name = repo.partition("/")
+    for pr in prs or []:
+        head_owner = ((pr.get("headRepositoryOwner") or {}).get("login") or "")
+        head_name = ((pr.get("headRepository") or {}).get("name") or "")
+        if head_owner.lower() == owner.lower() and head_name.lower() == name.lower():
+            return pr.get("number")
+    return None
+
+
+async def reap_orphaned_sessions(
+    state_db: Any,
+    *,
+    poller: Any,
+    github: Any,
+    worktree: Any,
+    is_alive: Callable[[int], bool] = owner_is_alive,
+    in_use: Callable[[str], bool | None] = worktree_in_use,
+) -> list[dict[str, Any]]:
+    """Settle every ``running`` session whose owning process is gone.
+
+    For each one:
+
+    - the row becomes ``failed`` with a summary saying why, and any repo
+      lock it held is dropped (one transaction, see
+      :meth:`StateDB.fail_orphaned_session`);
+    - its worktree, when there is one, is kept, and its HEAD detached
+      from the issue's branch when that can be done safely, so the next
+      run for the issue can check that branch out;
+    - a dev or task issue is removed from ``seen_issues`` so the next
+      poll takes it again, unless an open pull request was found for the
+      branch: then the pull request is the outcome and the issue stays
+      seen. When the lookup could not be made, the issue is handed back
+      anyway; the next run refuses a branch that backs an open pull
+      request on its own (``create_worktree_with_new_branch``);
+    - a comment on the issue names the worktree, and releases this
+      machine's claim by id where the row has one. A task run on a
+      single machine claims nothing and gets no comment.
+
+    Left alone: rows this process wrote (``owner_run``; a scheduled
+    sweep can start before this runs), rows whose owner is alive, rows
+    whose worktree a live process is still working in (the agent outlives
+    a relay killed on its own; see :func:`worktree_in_use`), and rows with
+    no ``owner_pid``. Those come from a version before #312 and name no
+    process, and could as well be a ``ctrlrelay run dev`` started by hand
+    and still running.
+
+    The row update comes first, so no later step touches a row something
+    else settled, and each step after it is best-effort. The cost is a
+    narrow gap: if this process dies between the update and the
+    hand-back, that row is no longer running and no later start looks at
+    it again. Returns one dict per row settled.
+    """
+    from ctrlrelay.pipelines.dev import reconcile_claim_on_failure
+
+    try:
+        rows = state_db.list_running_sessions()
+    except Exception as e:
+        log_event(
+            _logger, "orphans.list_failed",
+            reason=type(e).__name__, error=str(e)[:200],
+        )
+        return []
+
+    settled: list[dict[str, Any]] = []
+    for row in rows:
+        session_id = row["id"]
+        pid = row.get("owner_pid")
+        if row.get("owner_run") == PROCESS_RUN:
+            continue
+        if pid is None:
+            log_event(
+                _logger, "orphans.owner_unknown", session_id=session_id,
+                repo=row.get("repo"), issue_number=row.get("issue_number"),
+                operator_action=(
+                    "this row was written before ctrlrelay recorded which "
+                    "process runs a session; if no run is live, set its "
+                    "status to failed in state.db by hand"
+                ),
+            )
+            continue
+        if is_alive(int(pid)):
+            continue
+        worktree_path = row.get("worktree_path")
+        if worktree_path and Path(worktree_path).exists():
+            busy = in_use(worktree_path)
+            if busy is not False:
+                # In use, or could not be told: errs towards alive, as
+                # `owner_is_alive` does.
+                log_event(
+                    _logger,
+                    "orphans.worktree_in_use" if busy
+                    else "orphans.worktree_use_unknown",
+                    session_id=session_id,
+                    repo=row.get("repo"), worktree_path=worktree_path,
+                    operator_action=(
+                        "the relay process that ran this session is gone, "
+                        "but a process may still be working in its "
+                        "worktree, so it is left as running. Stop that "
+                        "process (or leave that directory) and restart the "
+                        "poller to settle it."
+                    ),
+                )
+                continue
+
+        repo = row["repo"]
+        issue_number = row.get("issue_number")
+        pipeline = row.get("pipeline")
+
+        summary = "Run stopped: " + orphan_reason(row, None)
+        try:
+            changed = state_db.fail_orphaned_session(session_id, summary)
+        except Exception as e:
+            log_event(
+                _logger, "orphans.update_failed", session_id=session_id,
+                reason=type(e).__name__, error=str(e)[:200],
+            )
+            continue
+        if not changed:
+            continue
+
+        # After the row, not before: a row something else settled in the
+        # meantime is not ours to touch, and neither is its worktree.
+        branch: str | None = None
+        if worktree_path and Path(worktree_path).exists():
+            try:
+                branch = worktree.detach_orphaned_worktree(repo, worktree_path)
+            except Exception as e:
+                log_event(
+                    _logger, "orphans.detach_failed", session_id=session_id,
+                    reason=type(e).__name__, error=str(e)[:200],
+                )
+
+        pr_number: int | None = None
+        handed_back = False
+        if issue_number is not None and pipeline in _ISSUE_PIPELINES:
+            pr_number = await _open_pr_for(github, repo, branch)
+            if pr_number is None:
+                poller.unmark_seen(repo, int(issue_number))
+                handed_back = True
+            claim_id = row.get("claim_id")
+            # A dev run always claims before its row exists. A task run
+            # claims only on a multi-machine setup, and posts nothing
+            # otherwise, so there is nothing of its to retract then.
+            if pipeline == "dev" or claim_id:
+                await reconcile_claim_on_failure(
+                    github,
+                    repo=repo,
+                    issue_number=int(issue_number),
+                    session_id=session_id,
+                    reason=orphan_reason(row, branch),
+                    exit_code=row.get("claude_exit_code"),
+                    pr_number=pr_number,
+                    claim_id=claim_id,
+                    will_retry=handed_back,
+                    # Only open pull requests were looked for, so "none
+                    # was opened" is never known: one may have been
+                    # closed or merged.
+                    pr_known=False,
+                )
+
+        log_event(
+            _logger, "orphans.reaped", session_id=session_id, repo=repo,
+            issue_number=issue_number, pipeline=pipeline, owner_pid=pid,
+            worktree_path=worktree_path, branch_freed=branch,
+            pr_number=pr_number, handed_back=handed_back,
+        )
+        settled.append({
+            "session_id": session_id,
+            "repo": repo,
+            "issue_number": issue_number,
+            "worktree_path": worktree_path,
+            "branch_freed": branch,
+            "pr_number": pr_number,
+            "handed_back": handed_back,
+        })
+    return settled