From bea7d7333228c52103e8cfb019d3e171ded7e571 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Davor=20Raci=C4=87?= <davor.racic@gmail.com>
Date: Wed, 14 Oct 2026 06:24:50 +0200
Subject: [PATCH 01/11] fix(cleanup): say when a displaced registry is another
 project's derived root

A displaced PSMUX_DATA_DIR shaped like a root bmad-loop derived for
another project path (or for this project before a rename) holds sessions
whose owner cannot be proven from here: the tag hashes a path and run ids
are caller-supplied. Report its sessions in full as before, but name the
registry for what it is instead of calling them "not migrated", in the
cleanup stderr line, the TUI toast and the displaced-root note. The
--json document is unchanged.

Closes #906
---
 CHANGELOG.md                 |  5 +++
 docs/multiplexer-backends.md | 15 ++++++++-
 src/bmad_loop/cli.py         | 32 +++++++++++++++---
 src/bmad_loop/runs.py        | 37 +++++++++++++++++++++
 src/bmad_loop/tui/app.py     |  9 ++++++
 tests/test_cli.py            | 62 +++++++++++++++++++++++++++++++++++
 tests/test_runs.py           | 63 ++++++++++++++++++++++++++++++++++++
 tests/test_tui_app.py        | 38 ++++++++++++++++++++++
 8 files changed, 255 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9e16144f..64ba3ce3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -88,6 +88,11 @@ breaking changes may land in a minor release.
 - Refuse psmux option values shaped `-X=value`, `-t…` or `--`: psmux 3.4.0 rewrites the
   first silently and rejects the others, so the value is now warned about and its key freed
   (#905).
+- Stop `cleanup` and the TUI from calling the sessions in a displaced registry `not migrated`
+  when it is another project's derived `PSMUX_DATA_DIR` (or this project's from before a
+  rename): name it as such and say its control session and untagged sessions most likely
+  belong to that project, while a session tagged as this project's is yours; the stderr
+  note names it too (#906).
 - Fire the TUI's stale state-root note on psmux too: the psmux backend now answers which
   value a new pane inherits through psmux 3.4.0's named `show-environment` (#660).
 - Fix the OpenCode V2 SSE-reconnect end-to-end test failing on slow runners (Windows): the
diff --git a/docs/multiplexer-backends.md b/docs/multiplexer-backends.md
index 71b317be..993e613f 100644
--- a/docs/multiplexer-backends.md
+++ b/docs/multiplexer-backends.md
@@ -202,9 +202,11 @@ repeats the warning. A server already running with it on is not detected. Unset
 before the per-project root: psmux's default registry, and any `PSMUX_DATA_DIR` root
 bmad-loop displaced. It kills only sessions that carry this project's ownership tag and
 whose run is not still going. Whatever it leaves is named on stderr as
-`left in <registry> (not migrated): …` and in `cleanup --json` at
+`left in <registry> (<label>): …` and in `cleanup --json` at
 `sessions.legacy_leftovers`; a registry that could not be asked at all is named as
 `legacy registry not checked …` (`sessions.legacy_unverified`, a toast in the TUI).
+The label is `not migrated`, except for a registry derived from another project path,
+which gets its own label (below).
 
 Three kinds stay behind by design:
 
@@ -213,6 +215,17 @@ Three kinds stay behind by design:
 - **A live session of your own.** Cleanup never kills a run whose engine is still going.
 - The shared **`bmad-loop-ctl` control session** in that registry.
 
+**Sessions in another registry.** A displaced root shaped like one bmad-loop derived
+(`<project tag>/_mux`) under a tag that is not this project's is reported in full like any
+other, but its line reads `left in <registry> (another project's derived registry, or this
+project's from before a rename): …` instead of `(not migrated)`. That is the root
+`bmad-loop mux` printed for another project, or for this one before it was renamed or moved,
+still exported in the shell. Its control session and untagged sessions most likely belong to
+that project: do not remove them from here. A session tagged as this project's is yours. A
+derived-shaped root whose tag cannot be compared gets the same wording. The
+`note: using bmad-loop's own psmux registry …` line that names the displaced root says it is
+such a registry, and `cleanup --json` is unchanged.
+
 To inspect one, put the shell on the registry the message named:
 
 ```powershell
diff --git a/src/bmad_loop/cli.py b/src/bmad_loop/cli.py
index 9b6b7e31..550483f2 100644
--- a/src/bmad_loop/cli.py
+++ b/src/bmad_loop/cli.py
@@ -249,9 +249,15 @@ def _configure_mux(project: Path) -> None:
         # An honoured value is the operator's own stated preference, so it gets
         # no note; `bmad-loop mux` still says which source won.
         if ambient is not None and ambient != root:
+            owner = (
+                f"is {runs.FOREIGN_REGISTRY}, left alone; its sessions most likely belong to "
+                "that project"
+                if runs.foreign_registry_root(ambient, project)
+                else "is left for your own sessions"
+            )
             print(
                 f"note: using bmad-loop's own psmux registry {root} — your "
-                f"{runs.PSMUX_DATA_DIR}={ambient} is left for your own sessions "
+                f"{runs.PSMUX_DATA_DIR}={ambient} {owner} "
                 f"(`bmad-loop mux` prints the export that reaches these)",
                 file=sys.stderr,
             )
@@ -6653,7 +6659,9 @@ def cmd_archive(args: argparse.Namespace) -> int:
 
 
 def _warn_legacy_leftovers(
-    leftovers: dict[str, list[str]], unverified: list[str] | tuple[str, ...] = ()
+    project: Path,
+    leftovers: dict[str, list[str]],
+    unverified: list[str] | tuple[str, ...] = (),
 ) -> None:
     """Name what each legacy multiplexer registry still holds after the sweep.
 
@@ -6687,13 +6695,27 @@ def _warn_legacy_leftovers(
 
     ``unverified`` names each legacy registry that could not be asked at all
     (DW-469): without a line for it, a registry that raised printed exactly what
-    a registry holding nothing prints — nothing."""
+    a registry holding nothing prints — nothing.
+
+    A registry shaped like a root bmad-loop derived from another project path
+    (`runs.foreign_registry_root`, #906) gets its own line: its control session
+    and untagged sessions are not a migration remainder but most likely that
+    project's, which is the one thing to say before anyone removes them. A
+    session tagged as ours there is still named, and is still ours."""
     for line in unverified:
         print(
             f"legacy registry not checked for sessions left behind (not migrated): {line}",
             file=sys.stderr,
         )
     for registry, names in leftovers.items():
+        if runs.foreign_registry_root(registry, project):
+            print(
+                f"left in {registry} ({runs.FOREIGN_REGISTRY}): "
+                + ", ".join(names)
+                + f" — {runs.FOREIGN_REGISTRY_HINT}",
+                file=sys.stderr,
+            )
+            continue
         print(
             f"left in {registry} (not migrated): "
             + ", ".join(names)
@@ -6809,7 +6831,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
                 print(f"would close ctl window {name}")
         if live:
             print(f"leaving {len(live)} live session(s) untouched")
-        _warn_legacy_leftovers(leftovers, unverified)
+        _warn_legacy_leftovers(project, leftovers, unverified)
         return 0
     # The count now excludes non-removals, so on stdout alone a smaller number is
     # indistinguishable from a quieter sweep — and `cleanup > log` keeps only
@@ -6827,7 +6849,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
         # Same wording as the TUI toast: one claim, one phrase, so an operator
         # moving between the two surfaces is reading the same thing.
         print(f"ctl window(s) still open after the kill: {', '.join(survived)}", file=sys.stderr)
-    _warn_legacy_leftovers(leftovers, unverified)
+    _warn_legacy_leftovers(project, leftovers, unverified)
     if unverifiable:
         # Not "killed but unverifiable": kill_window is a silent no-op on a
         # transport failure, so whether the kill even reached the server is part
diff --git a/src/bmad_loop/runs.py b/src/bmad_loop/runs.py
index 097bfc1f..e0e67b4c 100644
--- a/src/bmad_loop/runs.py
+++ b/src/bmad_loop/runs.py
@@ -730,6 +730,43 @@ def resolve_psmux_registry_root(derived: str, ambient: str | None, *, honor_ambi
     return ambient
 
 
+# What a root :func:`foreign_registry_root` answers True for is, in the words
+# the CLI and the TUI both print.
+FOREIGN_REGISTRY = "another project's derived registry, or this project's from before a rename"
+# What such a registry's leftovers are: `legacy_registry_leftovers` names a
+# session tagged as ours there too, so only the rest is that project's.
+FOREIGN_REGISTRY_HINT = (
+    "its control session and untagged sessions most likely belong to that project "
+    "(do not remove them from here); a session tagged as this project's is yours"
+)
+
+
+def foreign_registry_root(value: str | None, project: Path) -> bool:
+    """Whether ``value`` is a registry root bmad-loop derived from another
+    project path: ``<project tag>/``:data:`MUX_REGISTRY_DIR` with a tag that is
+    not ``project``'s own.
+
+    What ``bmad-loop mux`` printed for another project, or for this one before a
+    rename (the tag hashes the path), carried into this project's shell. Shape
+    and tag only: the tag is a hash of a path, so whose sessions such a registry
+    holds cannot be proven from here, and callers only *say* what it is.
+
+    Compared case-insensitively where the filesystem folds case: ``<TAG>\\_MUX``
+    is the same registry on Windows. Never raises: when this project's tag
+    cannot be derived, a derived-shaped root answers ``True``. Whose it is is
+    then unknown, and unknown ownership takes the cautious wording, not the
+    plain one that invites removal."""
+    if not value:
+        return False
+    root = Path(os.path.normcase(value))
+    if root.name != MUX_REGISTRY_DIR or not _PROJECT_TAG_RE.fullmatch(root.parent.name):
+        return False
+    try:
+        return root.parent.name != project_tag(project)
+    except (OSError, RuntimeError, ValueError):
+        return True
+
+
 # The project this process configured its registry for
 # (`export_psmux_registry_root`), or None before that ran. Process-local, set
 # once ahead of dispatch like the backend's displaced-root record; it is what
diff --git a/src/bmad_loop/tui/app.py b/src/bmad_loop/tui/app.py
index 97960857..e0c230b7 100644
--- a/src/bmad_loop/tui/app.py
+++ b/src/bmad_loop/tui/app.py
@@ -2108,6 +2108,15 @@ def _cleanup_sessions_worker(self) -> None:
                 markup=False,
             )
         for registry, names in leftovers.items():
+            if runs.foreign_registry_root(registry, self.project):
+                self.call_from_thread(
+                    self.notify,
+                    f"{len(names)} session(s) left in {registry} ({runs.FOREIGN_REGISTRY}): "
+                    f"{', '.join(names)} — {runs.FOREIGN_REGISTRY_HINT}",
+                    severity="warning",
+                    markup=False,
+                )
+                continue
             self.call_from_thread(
                 self.notify,
                 f"{len(names)} session(s) left in {registry} (not migrated): "
diff --git a/tests/test_cli.py b/tests/test_cli.py
index d8f6cf63..b3580c32 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -18736,6 +18736,28 @@ def test_main_says_once_when_it_overrode_an_operators_registry(
     assert captured.out == ""
     assert str(runs.mux_registry_root(tmp_path)) in captured.err
     assert theirs in captured.err
+    assert "left for your own sessions" in captured.err
+
+
+def test_main_names_another_projects_derived_registry_as_theirs(
+    force_psmux_backend, tmp_path, capsys, monkeypatch
+):
+    """#906: the ambient value is the export `bmad-loop mux` printed for another
+    project. Calling it "left for your own sessions" tells the operator a live
+    bmad-loop registry is theirs to tidy. Ablate the `foreign_registry_root`
+    branch of the note and this fails."""
+    monkeypatch.setenv(envvars.STATE_DIR, str(tmp_path / "state"))
+    other = tmp_path / "other"
+    other.mkdir()
+    theirs = str(runs.mux_registry_root(other))
+    monkeypatch.setenv(runs.PSMUX_DATA_DIR, theirs)
+    monkeypatch.setattr(cli, "cmd_list", lambda _args: 0)
+
+    assert cli.main(["list", "--project", str(tmp_path)]) == 0
+    err = capsys.readouterr().err
+    assert f"{runs.PSMUX_DATA_DIR}={theirs} is {runs.FOREIGN_REGISTRY}" in err
+    assert "most likely belong to that project" in err
+    assert "left for your own sessions" not in err
 
 
 @pytest.mark.parametrize("ambient", ["derived", None])
@@ -19483,6 +19505,46 @@ def test_cleanup_names_the_registry_each_leftover_is_actually_in(project, capsys
     assert "bmad-loop-old-1" in theirs_line and "bmad-loop-ctl" not in theirs_line
 
 
+def test_cleanup_says_a_derived_registry_of_another_project_path_is_not_a_remainder(
+    project, capsys, monkeypatch
+):
+    """#906: the shell exports the root `bmad-loop mux` printed for another
+    project, so its control session and untagged sessions are reported here.
+    "not migrated" and the removal hint send the operator after that project's
+    sessions; the line must say whose registry it most likely is. A plain
+    displaced root keeps the old wording. Ablate the `foreign_registry_root`
+    branch of `_warn_legacy_leftovers` and this fails."""
+    from bmad_loop.tui import launch
+
+    other = project.project.parent / "other"
+    theirs = str(project.project.parent / "state" / runs.project_tag(other) / runs.MUX_REGISTRY_DIR)
+    plain = r"D:\their-own-registry"
+    monkeypatch.setattr(runs, "prune_sessions", lambda _p, dry_run=False: ([], [], set()))
+    monkeypatch.setattr(
+        runs,
+        "legacy_registry_leftovers",
+        lambda _p, announced=(): (
+            {theirs: ["bmad-loop-bare-1", "bmad-loop-ctl"], plain: ["bmad-loop-old-1"]},
+            [],
+        ),
+    )
+    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
+
+    assert cli.main(["cleanup", "--project", str(project.project)]) == 0
+    lines = capsys.readouterr().err.splitlines()
+    theirs_line = next(ln for ln in lines if theirs in ln)
+    assert f"left in {theirs} ({runs.FOREIGN_REGISTRY}): bmad-loop-bare-1, bmad-loop-ctl" in (
+        theirs_line
+    )
+    # Leftovers there include a session tagged as ours, so the hint splits the
+    # claim: control and untagged sessions are that project's, tagged ones ours.
+    assert theirs_line.endswith(f" — {runs.FOREIGN_REGISTRY_HINT}")
+    assert "a session tagged as this project's is yours" in theirs_line
+    assert "not migrated" not in theirs_line
+    plain_line = next(ln for ln in lines if plain in ln)
+    assert f"left in {plain} (not migrated): bmad-loop-old-1" in plain_line
+
+
 def test_cleanup_json_flattens_the_remainder_to_the_documented_list(project, capsys, monkeypatch):
     """`sessions.legacy_leftovers` is a documented list of NAMES in a
     schema-versioned document, so the grouping serves the text mode only —
diff --git a/tests/test_runs.py b/tests/test_runs.py
index 39a367c0..b392a286 100644
--- a/tests/test_runs.py
+++ b/tests/test_runs.py
@@ -8899,6 +8899,69 @@ def test_legacy_registry_leftovers_names_a_surviving_control_session(tmp_path, m
     assert _healthy_leftovers(tmp_path) == {runs.DEFAULT_REGISTRY_LABEL: [runs.CTL_SESSION]}
 
 
+def test_legacy_leftovers_report_another_projects_derived_registry_in_full(tmp_path, monkeypatch):
+    """#906: whose sessions a derived registry of another project path holds
+    cannot be proven (the tag hashes a path; a renamed project's own old root
+    looks the same), so nothing in it is hidden: its control session and
+    untagged sessions are reported like any displaced registry's, and only the
+    wording says what it is. Another project's *tagged* session is still
+    skipped, as everywhere. Reintroduce a skip for such a root and this fails."""
+    theirs = str(tmp_path / "state" / runs.project_tag(tmp_path / "other") / runs.MUX_REGISTRY_DIR)
+    legacy = _RegistryMux(
+        [runs.CTL_SESSION, "bmad-loop-bare-1", "bmad-loop-b-1"],
+        {"bmad-loop-b-1": runs.project_tag(tmp_path / "other")},
+        root=theirs,
+    )
+    monkeypatch.setattr(runs, "_legacy_registries", lambda: [legacy])
+    assert runs.foreign_registry_root(theirs, tmp_path)
+    assert _healthy_leftovers(tmp_path) == {theirs: ["bmad-loop-bare-1", runs.CTL_SESSION]}
+
+
+def test_foreign_registry_root_is_a_shape_and_tag_check(tmp_path):
+    """True only for `<16-hex tag>/_mux` under a tag that is not this project's.
+    Ablate the tag comparison (or the shape check) and this fails."""
+    other_tag = runs.project_tag(tmp_path / "other")
+    state = tmp_path / "state"
+    assert runs.foreign_registry_root(str(state / other_tag / runs.MUX_REGISTRY_DIR), tmp_path)
+    # Our own tag, under any state root, is not another project path's.
+    mine = state / runs.project_tag(tmp_path) / runs.MUX_REGISTRY_DIR
+    assert not runs.foreign_registry_root(str(mine), tmp_path)
+    # Not the derived shape: wrong leaf, short tag, non-hex tag, empty, None.
+    assert not runs.foreign_registry_root(str(state / other_tag / "mux"), tmp_path)
+    assert not runs.foreign_registry_root(str(state / other_tag[:15] / "_mux"), tmp_path)
+    assert not runs.foreign_registry_root(str(state / ("g" * 16) / "_mux"), tmp_path)
+    assert not runs.foreign_registry_root(r"D:\their-own-registry", tmp_path)
+    assert not runs.foreign_registry_root("", tmp_path)
+    assert not runs.foreign_registry_root(None, tmp_path)
+
+
+def test_foreign_registry_root_never_raises(tmp_path, monkeypatch):
+    """When this project's tag cannot be derived, a derived-shaped root is of
+    unknown ownership, so it answers True (the cautious wording) rather than
+    failing the command that prints the note, or answering False (the plain
+    wording, which invites removal). Ablate the `except` and this raises;
+    answer False there and this fails."""
+
+    def _boom(_p):
+        raise OSError("unresolvable")
+
+    monkeypatch.setattr(runs, "project_tag", _boom)
+    root = str(tmp_path / ("a" * 16) / runs.MUX_REGISTRY_DIR)
+    assert runs.foreign_registry_root(root, tmp_path) is True
+
+
+@pytest.mark.skipif(sys.platform != "win32", reason="the registry path folds case on Windows only")
+def test_foreign_registry_root_folds_case_where_the_filesystem_does(tmp_path):
+    """`<TAG>\\_MUX` addresses the same registry as `<tag>\\_mux` on Windows, so
+    a case-varied spelling of this project's own root is not another project
+    path's, and of another's still is. Ablate the `normcase` and this fails."""
+    state = tmp_path / "state"
+    other = runs.project_tag(tmp_path / "other").upper()
+    assert runs.foreign_registry_root(str(state / other / "_MUX"), tmp_path)
+    mine = runs.project_tag(tmp_path).upper()
+    assert not runs.foreign_registry_root(str(state / mine / "_MUX"), tmp_path)
+
+
 def test_legacy_leftovers_names_a_case_variant_ctl_where_the_transport_folds(tmp_path, monkeypatch):
     """psmux resolves a session by opening `<data dir>\\<name>.port`, and NTFS
     opens names case-insensitively, so in ITS registry `bmad-loop-CTL-<hex>` is
diff --git a/tests/test_tui_app.py b/tests/test_tui_app.py
index 9b067d12..2749d713 100644
--- a/tests/test_tui_app.py
+++ b/tests/test_tui_app.py
@@ -3848,6 +3848,44 @@ async def test_cleanup_warns_about_sessions_left_in_the_legacy_registry(project,
         )
 
 
+async def test_cleanup_toast_names_another_projects_derived_registry(project, monkeypatch):
+    """#906, the cli arm's twin: a displaced root bmad-loop derived from another
+    project path holds that project's sessions most likely, and "not migrated"
+    sends the operator after them. Ablate the `foreign_registry_root` branch of
+    the toast and this fails."""
+    from bmad_loop import runs
+
+    theirs = str(
+        project.project.parent
+        / "state"
+        / runs.project_tag(project.project.parent / "other")
+        / runs.MUX_REGISTRY_DIR
+    )
+    monkeypatch.setattr(launch, "mux_available", lambda: True)
+    monkeypatch.setattr(runs, "prune_sessions", lambda _p: ([], [], set()))
+    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
+    monkeypatch.setattr(
+        runs, "legacy_registry_leftovers", lambda _p: ({theirs: ["bmad-loop-ctl"]}, [])
+    )
+    make_run(project.project, "20260611-100000-aaaa")
+    app = BmadLoopApp(project.project)
+    async with app.run_test() as pilot:
+        await until(pilot, lambda: isinstance(app.screen, DashboardScreen))
+        await pilot.press("c")
+        await until(pilot, lambda: isinstance(app.screen, ConfirmModal))
+        await click(pilot, await ready(pilot, "#ok"))
+        await until(
+            pilot,
+            lambda: any(
+                f"left in {theirs} ({runs.FOREIGN_REGISTRY})" in m
+                and "bmad-loop-ctl" in m
+                and runs.FOREIGN_REGISTRY_HINT in m
+                for m in notifications(app)
+            ),
+        )
+        assert not any("not migrated" in m for m in notifications(app))
+
+
 async def test_cleanup_warns_about_a_legacy_registry_that_could_not_be_asked(project, monkeypatch):
     """DW-469, the cli arm's twin: a registry whose listing raised used to toast
     exactly what an empty one toasts — nothing. Ablate the `unverified` toast and

From b18bc6791726e33fe596c8c5989a236842016b1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Davor=20Raci=C4=87?= <davor.racic@gmail.com>
Date: Wed, 14 Oct 2026 01:32:04 +0200
Subject: [PATCH 02/11] fix(cleanup): report a pre-upgrade
 bmad-loop-ctl-<digest> control session

After the control session went back to one fixed name, a session started
under the old bmad-loop-ctl-<16 hex> name could keep running in the project's
own registry, holding a parked run window, and nothing named it: cleanup said
nothing to clean up, --json reported no leftovers and attach found nothing.
cleanup now names it on stderr and in sessions.legacy_leftovers, with the
command that ends it in sessions.legacy_kill_commands, and attach names it
when it finds nothing to attach. attach does not adopt the session: stop, the
parked-window sweep and the decision return path do not address it.

Refs #733
---
 CHANGELOG.md                 |   4 +
 docs/multiplexer-backends.md |   7 +-
 docs/reference/cli.md        |   2 +-
 src/bmad_loop/cli.py         |  99 +++++++++++++++++++++++
 src/bmad_loop/documents.py   |   8 ++
 src/bmad_loop/runs.py        |  71 +++++++++++++++++
 tests/test_cli.py            | 150 +++++++++++++++++++++++++++++++++++
 tests/test_runs.py           |  89 +++++++++++++++++++++
 8 files changed, 428 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 64ba3ce3..37bf82e6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -93,6 +93,10 @@ breaking changes may land in a minor release.
   rename): name it as such and say its control session and untagged sessions most likely
   belong to that project, while a session tagged as this project's is yours; the stderr
   note names it too (#906).
+- Report a pre-upgrade `bmad-loop-ctl-<16 hex>` control session left in the project's own
+  psmux registry: `cleanup` names it on stderr and in `sessions.legacy_leftovers` with the
+  command that ends it (`sessions.legacy_kill_commands`), and `attach` names it when it finds
+  nothing to attach (#733).
 - Fire the TUI's stale state-root note on psmux too: the psmux backend now answers which
   value a new pane inherits through psmux 3.4.0's named `show-environment` (#660).
 - Fix the OpenCode V2 SSE-reconnect end-to-end test failing on slow runners (Windows): the
diff --git a/docs/multiplexer-backends.md b/docs/multiplexer-backends.md
index 993e613f..6ff1c344 100644
--- a/docs/multiplexer-backends.md
+++ b/docs/multiplexer-backends.md
@@ -137,7 +137,12 @@ prunes it. Nothing launches into it, though, so the TUI's attach and stop keys a
 parked-window sweep do not reach its windows. To end one, let its runs finish
 (`bmad-loop stop` reaches a live engine wherever it runs) and check that every window shows
 the exit banner (see `capture-pane` below). Then run
-`psmux kill-session -t bmad-loop-ctl-<16 hex>`.
+`psmux kill-session -t bmad-loop-ctl-<16 hex>`. `cleanup` names the one an earlier release
+started for this project in its registry (matched by that exact name, since a run id
+`ctl-<16 hex>` gives an agent session the same shape) on stderr and in
+`sessions.legacy_leftovers`, with that command ready to paste
+(`sessions.legacy_kill_commands` in `--json`). `attach` names it when it finds nothing to
+attach, with `switch-client` instead of `attach` when run inside a psmux pane.
 
 **If the state root cannot be derived** (for example, `BMAD_LOOP_STATE_DIR` is a relative
 path), bmad-loop says so and leaves whatever `PSMUX_DATA_DIR` was in force. `cleanup` then
diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index 657923fd..c680fa1e 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -546,7 +546,7 @@ The `--dry-run` plan and the outcome share this shape.
 | `sessions`    | object | agent sessions (below)         |
 | `ctl_windows` | object | control windows (below)        |
 
-`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_unverified`, and `scan_error` (present only when the scan failed).
+`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_kill_commands` (a pre-upgrade control session in this project's registry mapped to the command that ends it), `legacy_unverified`, and `scan_error` (present only when the scan failed).
 
 `ctl_windows`: `removed` (verified gone, or would close under `--dry-run`), `survived`, `unverifiable` (kill outcome could not be checked), `undetermined` (kept because the window's state could not be read), `scan_error` (str or null; when set, the other lists mean "no answer").
 
diff --git a/src/bmad_loop/cli.py b/src/bmad_loop/cli.py
index 550483f2..a12bd2d2 100644
--- a/src/bmad_loop/cli.py
+++ b/src/bmad_loop/cli.py
@@ -6434,6 +6434,48 @@ def cmd_list(args: argparse.Namespace) -> int:
     return 0
 
 
+def _note_superseded_ctl_for_attach(project: Path) -> None:
+    """After "nothing to attach": name each pre-upgrade control session still
+    standing in this project's registry (#733), with the command that attaches
+    to it, because a run window parked there is one attach cannot see.
+
+    Named, not adopted. attach, stop and the parked-window sweep address
+    ``runs.ctl_session_for`` only (see ``runs.is_ctl_session_name``); finding
+    a window here would land the operator in a session `stop` cannot then
+    close the window of, and a decision answered there would hand its client
+    back to nowhere. So the operator is pointed at it and the session ends when
+    they end it (`cleanup` prints how).
+
+    The verb is the one attach itself would run here: inside a multiplexer
+    client a nested attach is refused, so the backend switches the client
+    instead (``attach_target_argv``). A listing that could not be taken is said,
+    not passed off as "no such session" after "nothing to attach"."""
+    from .adapters.multiplexer import MultiplexerError, get_multiplexer
+
+    def _fault(msg: str) -> None:
+        print(
+            f"note: could not check this project's registry for a pre-upgrade control "
+            f"session: {msg}",
+            file=sys.stderr,
+        )
+
+    try:
+        mux = get_multiplexer()
+        stale = runs.superseded_ctl_sessions(project, mux, on_fault=_fault)
+    except MultiplexerError as exc:
+        _fault(str(exc))
+        return
+    for name in stale:
+        verb = mux.attach_target_argv(f"={name}")[1]
+        command = _psmux_command(mux.registry_root(), f"{verb} -t '={name}'")
+        print(
+            f"note: pre-upgrade control session {name} is still running in this "
+            f"project's registry, and attach does not look inside it; this run's "
+            f"window may be there: {command}",
+            file=sys.stderr,
+        )
+
+
 def cmd_attach(args: argparse.Namespace) -> int:
     from .tui import launch  # import-safe: launch.py has no textual imports
 
@@ -6470,6 +6512,7 @@ def ctl_fault(msg: str) -> None:
             # Not after a ctl fault: "nothing to attach" would claim the
             # unchecked ctl window absent (#750). The warning above stands.
             print(f"nothing to attach for run {run_dir.name}", file=sys.stderr)
+            _note_superseded_ctl_for_attach(project)
         return 1
     argv, return_window = plan
     # Record where to send the client once the sweep finishes this cycle's
@@ -6658,6 +6701,58 @@ def cmd_archive(args: argparse.Namespace) -> int:
     return 0
 
 
+def _psmux_command(registry: str | None, verb: str) -> str:
+    """A paste-ready PowerShell line running ``psmux <verb>`` against
+    ``registry`` (psmux's own default when ``None``). Quoted the way
+    ``_mux_info`` quotes its export line. ponytail: psmux is the only bundled
+    transport with a registry namespace, which is the only place the
+    sessions this spells a command for can exist."""
+    run = f"psmux {verb}"
+    if registry is None:
+        return run
+    quoted = registry.replace("'", "''")
+    return f"$env:{runs.PSMUX_DATA_DIR} = '{quoted}'; {run}"
+
+
+def _superseded_ctl_kill_commands(project: Path, leftovers: dict[str, list[str]]) -> dict[str, str]:
+    """``{name: command that ends it}`` for each control session in this
+    project's own registry under a name this release no longer mints (#733),
+    picked out of ``leftovers`` rather than listed a second time.
+
+    A command here and none for the other leftovers, because this session is
+    ours beyond doubt — the registry is the project's own — and nothing else
+    will ever end it: no bmad-loop command addresses it. The caveat travels
+    with the command: ending it kills whatever its windows still run."""
+    if not leftovers:
+        return {}
+    from .adapters.multiplexer import MultiplexerError, get_multiplexer
+
+    try:
+        mux = get_multiplexer()
+        old = mux.session_name_key(runs.superseded_ctl_name(project))
+    except (MultiplexerError, runs.StateRootError, OSError, RuntimeError):
+        return {}
+    root = mux.registry_root()
+    # The exact name `runs.superseded_ctl_sessions` matched, never the shape: a
+    # run's agent session `bmad-loop-ctl-<16 hex>` is spelled the same way.
+    return {
+        name: _psmux_command(root, f"kill-session -t '={name}'")
+        for name in leftovers.get(root or runs.DEFAULT_REGISTRY_LABEL, [])
+        if mux.session_name_key(name) == old
+    }
+
+
+def _warn_superseded_ctl(kill_commands: dict[str, str]) -> None:
+    for name, command in kill_commands.items():
+        print(
+            f"pre-upgrade control session {name} is still running in this project's "
+            "registry, and no bmad-loop command addresses it; once its runs have "
+            "finished and every window in it shows the exit banner (ending it kills "
+            f"what they still run), end it with: {command}",
+            file=sys.stderr,
+        )
+
+
 def _warn_legacy_leftovers(
     project: Path,
     leftovers: dict[str, list[str]],
@@ -6742,6 +6837,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
     leftovers, unverified = runs.legacy_registry_leftovers(
         project, announced=killed if args.dry_run else ()
     )
+    kill_commands = _superseded_ctl_kill_commands(project, leftovers)
     # The listing behind prune_sessions reads an unavailable backend as no
     # sessions; this names the cases where that is not a clean answer (#864).
     # A misconfigured process host fails the liveness read behind it: a scan
@@ -6817,6 +6913,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
                 # grouping serves the text mode, which has room to say where.
                 legacy_leftovers=sorted({n for names in leftovers.values() for n in names}),
                 legacy_unverified=unverified,
+                legacy_kill_commands=kill_commands,
                 sessions_scan_error=sessions_scan_error,
             )
         )
@@ -6832,6 +6929,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
         if live:
             print(f"leaving {len(live)} live session(s) untouched")
         _warn_legacy_leftovers(project, leftovers, unverified)
+        _warn_superseded_ctl(kill_commands)
         return 0
     # The count now excludes non-removals, so on stdout alone a smaller number is
     # indistinguishable from a quieter sweep — and `cleanup > log` keeps only
@@ -6850,6 +6948,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
         # moving between the two surfaces is reading the same thing.
         print(f"ctl window(s) still open after the kill: {', '.join(survived)}", file=sys.stderr)
     _warn_legacy_leftovers(project, leftovers, unverified)
+    _warn_superseded_ctl(kill_commands)
     if unverifiable:
         # Not "killed but unverifiable": kill_window is a silent no-op on a
         # transport failure, so whether the kill even reached the server is part
diff --git a/src/bmad_loop/documents.py b/src/bmad_loop/documents.py
index 8839bac6..9c118deb 100644
--- a/src/bmad_loop/documents.py
+++ b/src/bmad_loop/documents.py
@@ -397,6 +397,7 @@ def cleanup_document(
     windows_undetermined: list[str] | None = None,
     legacy_leftovers: list[str] | None = None,
     legacy_unverified: list[str] | None = None,
+    legacy_kill_commands: dict[str, str] | None = None,
     sessions_scan_error: str | None = None,
 ) -> dict[str, object]:
     """The `cleanup --json` document: the multiplexer artifacts this invocation
@@ -458,6 +459,12 @@ def cleanup_document(
     `legacy_unverified` means "not looked at", not "nothing left". Additive, no
     schema bump; the text mode prints each line on stderr.
 
+    `sessions.legacy_kill_commands` maps each pre-upgrade control session in
+    this project's own registry (#733) — also named in `legacy_leftovers` — to
+    the paste-ready command that ends it. No bmad-loop command addresses such a
+    session, so this is the only way out; run it once every window in it has
+    parked. Additive, no schema bump; the text mode prints each on stderr.
+
     `sessions.scan_error` is present only when the session listing could not
     see this project's sessions (#864): the backend is unavailable while a run
     of this project is or may be alive (`runs.session_scan_error`). `removed` and
@@ -478,6 +485,7 @@ def cleanup_document(
         "unverifiable_pid": sorted(unknown),
         "legacy_leftovers": list(legacy_leftovers or []),
         "legacy_unverified": list(legacy_unverified or []),
+        "legacy_kill_commands": dict(legacy_kill_commands or {}),
     }
     if sessions_scan_error is not None:
         sessions["scan_error"] = sessions_scan_error
diff --git a/src/bmad_loop/runs.py b/src/bmad_loop/runs.py
index e0e67b4c..b18133c9 100644
--- a/src/bmad_loop/runs.py
+++ b/src/bmad_loop/runs.py
@@ -2525,9 +2525,80 @@ def legacy_registry_leftovers(
             # rows are merged rather than overwritten.
             label = legacy.registry_root() or DEFAULT_REGISTRY_LABEL
             grouped[label] = sorted(set(grouped.get(label, []) + here))
+    # The project's own registry is no legacy one, but a control session an
+    # earlier release named there survives the rename too (#733).
+    primary = get_multiplexer()
+    label = primary.registry_root() or DEFAULT_REGISTRY_LABEL
+    try:
+        stale = superseded_ctl_sessions(
+            project, primary, on_fault=lambda msg: faults.append(f"{label}: {msg}")
+        )
+    except MultiplexerError as exc:
+        faults.append(f"{label}: could not be listed: {exc}")
+        stale = []
+    if stale:
+        grouped[label] = sorted(set(grouped.get(label, []) + stale))
     return grouped, faults
 
 
+def superseded_ctl_name(project: Path) -> str:
+    """The control-session name an earlier release minted for ``project`` in its
+    own derived registry (#733): ``bmad-loop-ctl-`` plus the first 16 hex of the
+    SHA-256 of that root, resolved and case-folded where the filesystem folds.
+
+    The formula that release used, kept verbatim for this one reader. Its
+    honoured-operator-root arm salted the digest with that root too, but
+    :func:`superseded_ctl_sessions` only reads the derived registry, where the
+    salt was never added.
+
+    Raises :class:`StateRootError` or ``OSError`` when the root cannot be
+    derived."""
+    scope = os.path.normcase(str(mux_registry_root(project).resolve()))
+    return f"{CTL_SESSION}-{hashlib.sha256(os.fsencode(scope)).hexdigest()[:16]}"
+
+
+def superseded_ctl_sessions(
+    project: Path,
+    mux: TerminalMultiplexer | None = None,
+    *,
+    on_fault: Callable[[str], None] | None = None,
+) -> list[str]:
+    """The control session standing in this process's own registry under the
+    name an earlier release minted for this project on psmux,
+    :func:`superseded_ctl_name` (#733), as each spelling is listed.
+
+    That exact name, not every ``bmad-loop-ctl-<16 hex>`` shape: a run's own
+    agent session for run id ``ctl-<16 hex>`` is spelled the same way, and
+    naming it here would publish a kill command for a live run.
+
+    Nothing addresses them: launches, attach, stop and the parked-window sweep
+    use :func:`ctl_session_for` only, and the prune spares every ctl-shaped
+    name (:func:`is_ctl_session_name`). A run window parked in one is reached by
+    no command, so this is what the cleanup and attach frontends name.
+
+    Only when the registry in force is this project's derived one
+    (:func:`mux_registry_root`): a control session in it is this project's.
+    psmux's shared default registry, an operator's own root, and a
+    machine-wide server (tmux, which never minted the digest shape) prove
+    nothing about whose a session spelled that way is.
+
+    A listing that could not be taken goes to ``on_fault`` and answers ``[]``
+    (:meth:`~.multiplexer.TerminalMultiplexer.list_sessions_reporting`)."""
+    mux = mux or get_multiplexer()
+    root = mux.registry_root()
+    try:
+        if root is None or Path(root) != mux_registry_root(project):
+            return []
+        old = mux.session_name_key(superseded_ctl_name(project))
+    except (StateRootError, OSError, RuntimeError):
+        return []
+    return sorted(
+        name
+        for name in mux.list_sessions_reporting(on_fault=on_fault)
+        if mux.session_name_key(name) == old
+    )
+
+
 def _legacy_registries() -> list[TerminalMultiplexer]:
     """Backends bound to registries this project's sessions may predate, or []
     (see :meth:`~.multiplexer.TerminalMultiplexer.legacy_registries`, which owns
diff --git a/tests/test_cli.py b/tests/test_cli.py
index b3580c32..2224d396 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -59,6 +59,7 @@
 from bmad_loop import probe as probe_mod
 from bmad_loop import runs, runsetup, verify
 from bmad_loop.adapters import multiplexer as mux_mod
+from bmad_loop.adapters.psmux_backend import PsmuxMultiplexer
 from bmad_loop.plugins import GrantSet
 
 STORIES_SPEC_FOLDER = "_bmad-output/epic-1"
@@ -2892,6 +2893,107 @@ def test_attach_nothing_to_attach(project, monkeypatch, capsys):
     assert "no readable project tag" not in err
 
 
+_DIGEST_CTL = runs.CTL_SESSION + "-0123456789abcdef"
+_OWN_REG = r"C:\state\0123456789abcdef\_mux"
+
+
+class _OwnRegistryMux:
+    """The primary backend as the #733 readers see it: bound to this project's
+    registry, which holds a control session under the pre-rename digest name."""
+
+    _BINARY = "psmux"
+    # The real client verb choice, so the printed command follows it.
+    attach_target_argv = PsmuxMultiplexer.attach_target_argv
+
+    def has_registry_namespace(self):
+        return False  # keeps `_configure_mux` from exporting a root over this fake
+
+    def registry_root(self):
+        return _OWN_REG
+
+    def session_name_key(self, name):
+        return name
+
+
+def test_attach_names_a_pre_upgrade_control_session_it_cannot_see_into(
+    project, monkeypatch, capsys
+):
+    """#733: a run window parked in the pre-rename control session is one attach
+    does not look at, so "nothing to attach" alone tells the operator nothing is
+    there. The session is named with the command that reaches it. Ablate the
+    `_note_superseded_ctl_for_attach` call in `cmd_attach` and this fails."""
+    from bmad_loop.tui import launch
+
+    _make_run_with_decision(project, run_id="20260101-000000-aaaa")
+    monkeypatch.setattr(launch, "attach_plan", lambda proj, rid, **_kw: (None, 0))
+    monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OwnRegistryMux())
+    monkeypatch.setattr(runs, "superseded_ctl_sessions", lambda _p, _m=None, **_kw: [_DIGEST_CTL])
+    monkeypatch.delenv("TMUX", raising=False)
+
+    assert cli.main(["attach", "--project", str(project.project), "20260101-000000-aaaa"]) == 1
+    err = capsys.readouterr().err
+    assert "nothing to attach" in err
+    assert (
+        f"pre-upgrade control session {_DIGEST_CTL} is still running" in err
+        and f"$env:PSMUX_DATA_DIR = '{_OWN_REG}'; psmux attach -t '={_DIGEST_CTL}'" in err
+    )
+
+
+def test_attach_inside_a_client_names_switch_client_not_a_nested_attach(
+    project, monkeypatch, capsys
+):
+    """Run from inside a psmux pane (`TMUX` set), a pasted `psmux attach` is a
+    nested attach, which is refused; the backend's own attach switches the
+    client instead, and the printed command must too. Ablate the
+    `attach_target_argv` verb in `_note_superseded_ctl_for_attach` (back to a
+    fixed `attach`) and this fails."""
+    from bmad_loop.tui import launch
+
+    _make_run_with_decision(project, run_id="20260101-000000-aaaa")
+    monkeypatch.setattr(launch, "attach_plan", lambda proj, rid, **_kw: (None, 0))
+    monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OwnRegistryMux())
+    monkeypatch.setattr(runs, "superseded_ctl_sessions", lambda _p, _m=None, **_kw: [_DIGEST_CTL])
+    monkeypatch.setenv("TMUX", "/tmp/psmux,1,0")
+
+    assert cli.main(["attach", "--project", str(project.project), "20260101-000000-aaaa"]) == 1
+    err = capsys.readouterr().err
+    assert f"psmux switch-client -t '={_DIGEST_CTL}'" in err
+    assert "psmux attach" not in err
+
+
+@pytest.mark.parametrize("how", ["raises", "reports"])
+def test_attach_says_when_it_could_not_look_for_a_pre_upgrade_control_session(
+    project, monkeypatch, capsys, how
+):
+    """After "nothing to attach", a listing that could not be taken must not read
+    as "no pre-upgrade control session either". Both ways a backend can fail it
+    are said: a raised `MultiplexerError` (an out-of-tree backend inheriting the
+    default `list_sessions_reporting`) and a reported fault. Ablate either the
+    `except` report or the `on_fault` handed to `superseded_ctl_sessions` in
+    `_note_superseded_ctl_for_attach` and this fails."""
+    from bmad_loop.tui import launch
+
+    def _stale(_p, _m=None, *, on_fault=None):
+        if how == "raises":
+            raise mux_mod.MultiplexerError("list-sessions timed out")
+        assert on_fault is not None
+        on_fault("list-sessions timed out")
+        return []
+
+    _make_run_with_decision(project, run_id="20260101-000000-aaaa")
+    monkeypatch.setattr(launch, "attach_plan", lambda proj, rid, **_kw: (None, 0))
+    monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OwnRegistryMux())
+    monkeypatch.setattr(runs, "superseded_ctl_sessions", _stale)
+
+    assert cli.main(["attach", "--project", str(project.project), "20260101-000000-aaaa"]) == 1
+    err = capsys.readouterr().err
+    assert "nothing to attach" in err
+    assert (
+        "could not check this project's registry for a pre-upgrade control session: "
+        "list-sessions timed out"
+    ) in err
+
+
 def test_attach_explains_an_unproven_ctl_window(project, monkeypatch, capsys):
     # #750: a window under this run's name was refused for an empty tag (unset,
     # or unreadable). With nothing else to attach the exit code stays the
@@ -7107,6 +7209,7 @@ def test_cleanup_json_dry_run_plans_without_pruning(tmp_path, monkeypatch, capsy
         "live": ["live-1"],
         "unverifiable_pid": [],
         "legacy_leftovers": [],
+        "legacy_kill_commands": {},
         "legacy_unverified": [],
     }
     assert doc["ctl_windows"] == {
@@ -7165,6 +7268,7 @@ def test_cleanup_json_nothing_to_clean_up_is_a_valid_empty_document(tmp_path, mo
         "live": [],
         "unverifiable_pid": [],
         "legacy_leftovers": [],
+        "legacy_kill_commands": {},
         "legacy_unverified": [],
     }
     assert doc["ctl_windows"] == {
@@ -19587,6 +19691,51 @@ def test_cleanup_says_nothing_about_a_registry_with_no_remainder(project, capsys
     assert "not migrated" not in err and "not checked" not in err
 
 
+def test_cleanup_prints_the_kill_command_for_a_pre_upgrade_control_session(
+    project, capsys, monkeypatch
+):
+    """#733: a control session the previous release named `bmad-loop-ctl-<hex>`
+    in this project's own registry is addressed by no command, so cleanup gives
+    the one that ends it — on stderr in text mode, at
+    `sessions.legacy_kill_commands` in --json with stderr empty. Only for that
+    session: the current control session and the other leftovers get none.
+    Nor for another `bmad-loop-ctl-<16 hex>`: only the exact name the previous
+    release minted for this project gets one. Ablate `_superseded_ctl_kill_commands`
+    to `{}`, or its exact-name match back to the shape check, and this fails."""
+    from bmad_loop.tui import launch
+
+    monkeypatch.setattr(runs, "prune_sessions", lambda _p, dry_run=False: ([], [], set()))
+    monkeypatch.setattr(
+        runs,
+        "legacy_registry_leftovers",
+        lambda _p, announced=(): (
+            {
+                # A run's agent session for run id `ctl-<16 hex>` shares the
+                # digest shape; it is not the old control session.
+                _OWN_REG: [runs.CTL_SESSION, _DIGEST_CTL, runs.CTL_SESSION + "-fedcba9876543210"],
+                "/reg/default": ["bmad-loop-old-1"],
+            },
+            [],
+        ),
+    )
+    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
+    monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OwnRegistryMux())
+    monkeypatch.setattr(runs, "superseded_ctl_name", lambda _p: _DIGEST_CTL)
+    command = f"$env:PSMUX_DATA_DIR = '{_OWN_REG}'; psmux kill-session -t '={_DIGEST_CTL}'"
+
+    assert cli.main(["cleanup", "--dry-run", "--project", str(project.project)]) == 0
+    err = capsys.readouterr().err
+    assert f"pre-upgrade control session {_DIGEST_CTL}" in err and command in err
+    assert err.count("kill-session") == 1
+
+    assert cli.main(["cleanup", "--json", "--project", str(project.project)]) == 0
+    captured = capsys.readouterr()
+    doc = json.loads(captured.out)
+    assert doc["sessions"]["legacy_kill_commands"] == {_DIGEST_CTL: command}
+    assert _DIGEST_CTL in doc["sessions"]["legacy_leftovers"]
+    assert captured.err == ""
+
+
 def test_cleanup_names_a_legacy_registry_that_could_not_be_asked(project, capsys, monkeypatch):
     """DW-469: a registry whose listing raised used to print exactly what an empty
     one prints — nothing. Text names it on stderr; --json carries it as
@@ -20261,6 +20410,7 @@ def test_cleanup_json_unavailable_backend_without_evidence_is_unchanged(
         "live": [],
         "unverifiable_pid": [],
         "legacy_leftovers": [],
+        "legacy_kill_commands": {},
         "legacy_unverified": [],
     }
     assert doc["ctl_windows"]["scan_error"] is None
diff --git a/tests/test_runs.py b/tests/test_runs.py
index b392a286..db3d5cad 100644
--- a/tests/test_runs.py
+++ b/tests/test_runs.py
@@ -8962,6 +8962,95 @@ def test_foreign_registry_root_folds_case_where_the_filesystem_does(tmp_path):
     assert not runs.foreign_registry_root(str(state / mine / "_MUX"), tmp_path)
 
 
+_DIGEST_CTL = runs.CTL_SESSION + "-0123456789abcdef"
+
+
+def test_superseded_ctl_sessions_names_the_pre_rename_session_in_our_registry(tmp_path):
+    """#733: the control session the previous release named `bmad-loop-ctl-<hex>`
+    survives the rename in this project's own registry, and nothing addresses
+    it — under the spelling it was listed with, read through the transport's
+    fold (ablate `session_name_key` there and the upper-case one drops out).
+    The current one, under any spelling the transport folds onto it, and a run's
+    agent session are not superseded. Nor is another digest-shaped name: a run
+    id `ctl-<16 hex>` mints exactly that shape for a live agent session (ablate
+    the exact-name match back to `is_ctl_session_name` and this fails)."""
+    own = str(runs.mux_registry_root(tmp_path))
+    old = runs.superseded_ctl_name(tmp_path)
+    assert old != _DIGEST_CTL and runs.is_ctl_session_name(old)
+    mux = _RegistryMux(
+        [
+            runs.CTL_SESSION,
+            runs.CTL_SESSION.upper(),
+            old,
+            old.upper(),
+            _DIGEST_CTL,
+            "bmad-loop-run-1",
+        ],
+        {},
+        root=own,
+        fold=True,
+    )
+    assert runs.superseded_ctl_sessions(tmp_path, mux) == [old.upper(), old]
+
+
+def test_superseded_ctl_name_is_the_previous_releases_mint(tmp_path):
+    """The name the previous release's `ctl_session_for` minted in a project's
+    own derived registry: the digest of that root, resolved and case-folded.
+    Pinned against the formula spelled out here, so a drift in either the root
+    derivation or the hashing fails."""
+    import hashlib
+
+    scope = os.path.normcase(str(runs.mux_registry_root(tmp_path).resolve()))
+    digest = hashlib.sha256(os.fsencode(scope)).hexdigest()[:16]
+    assert runs.superseded_ctl_name(tmp_path) == f"{runs.CTL_SESSION}-{digest}"
+
+
+@pytest.mark.parametrize("root", [None, "elsewhere"])
+def test_superseded_ctl_sessions_claims_nothing_outside_our_own_registry(tmp_path, root):
+    """psmux's shared default registry (`None`) and any root that is not this
+    project's derived one hold sessions of other projects and of the operator:
+    a digest-named control session there proves nothing about whose it is.
+    Ablate the `own` check in `superseded_ctl_sessions` and this fails."""
+    reg = None if root is None else str(tmp_path / root)
+    mux = _RegistryMux([_DIGEST_CTL], {}, root=reg)
+    assert runs.superseded_ctl_sessions(tmp_path, mux) == []
+
+
+def test_legacy_leftovers_name_a_pre_rename_control_session_in_our_own_registry(
+    tmp_path, monkeypatch
+):
+    """#733: `cleanup` said "nothing to clean up" and `legacy_leftovers: []`
+    while the pre-rename control session held a parked run window, because the
+    reader walked the legacy registries only. Ablate the primary pass in
+    `legacy_registry_leftovers` and this fails."""
+    own = str(runs.mux_registry_root(tmp_path))
+    old = runs.superseded_ctl_name(tmp_path)
+    monkeypatch.setattr(runs, "_legacy_registries", lambda: [])
+    monkeypatch.setattr(
+        runs,
+        "get_multiplexer",
+        lambda: _RegistryMux([runs.CTL_SESSION, old, _DIGEST_CTL], {}, root=own),
+    )
+    assert _healthy_leftovers(tmp_path) == {own: [old]}
+
+
+def test_legacy_leftovers_report_an_unreadable_own_registry(tmp_path, monkeypatch):
+    """A listing of the project's own registry that failed is "not looked at",
+    never "nothing left" (the DW-469 rule the legacy registries already follow).
+    Ablate the `on_fault` handed to `superseded_ctl_sessions` and this fails."""
+
+    class _Faulting(_RegistryMux):
+        def list_sessions_reporting(self, *, on_fault=None):
+            assert on_fault is not None
+            on_fault("list-sessions failed")
+            return []
+
+    own = str(runs.mux_registry_root(tmp_path))
+    monkeypatch.setattr(runs, "_legacy_registries", lambda: [])
+    monkeypatch.setattr(runs, "get_multiplexer", lambda: _Faulting([], {}, root=own))
+    assert runs.legacy_registry_leftovers(tmp_path) == ({}, [f"{own}: list-sessions failed"])
+
+
 def test_legacy_leftovers_names_a_case_variant_ctl_where_the_transport_folds(tmp_path, monkeypatch):
     """psmux resolves a session by opening `<data dir>\\<name>.port`, and NTFS
     opens names case-insensitively, so in ITS registry `bmad-loop-CTL-<hex>` is

From 5ddb8e8a2920c4f747d522e1bdb4377d077511c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Davor=20Raci=C4=87?= <davor.racic@gmail.com>
Date: Wed, 14 Oct 2026 08:28:44 +0200
Subject: [PATCH 03/11] fix(cleanup): find a pre-upgrade control session
 through an alias of the registry

The previous release minted the old control-session name from the resolved,
case-folded registry root, so an honoured PSMUX_DATA_DIR that is a symlink,
junction or other spelling of the project's derived registry held that
name. Compare the registry identities the same way instead of as spelled.
A root that cannot be resolved falls back to the as-spelled comparison and
reports the degrade through on_fault, which cleanup lists under
legacy_unverified and attach prints as a note.

Refs #733
---
 src/bmad_loop/runs.py | 21 ++++++++++++++++++---
 tests/test_runs.py    | 42 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 60 insertions(+), 3 deletions(-)

diff --git a/src/bmad_loop/runs.py b/src/bmad_loop/runs.py
index b18133c9..9b026453 100644
--- a/src/bmad_loop/runs.py
+++ b/src/bmad_loop/runs.py
@@ -2580,18 +2580,33 @@ def superseded_ctl_sessions(
     (:func:`mux_registry_root`): a control session in it is this project's.
     psmux's shared default registry, an operator's own root, and a
     machine-wide server (tmux, which never minted the digest shape) prove
-    nothing about whose a session spelled that way is.
+    nothing about whose a session spelled that way is. Compared as the old mint
+    compared them, resolved and then case-folded: an honoured root that is a
+    symlink, junction or other spelling of the derived one is that registry,
+    and the old mint gave it the same name. A root that cannot be resolved is
+    compared as spelled, and that degrade goes to ``on_fault``.
 
     A listing that could not be taken goes to ``on_fault`` and answers ``[]``
     (:meth:`~.multiplexer.TerminalMultiplexer.list_sessions_reporting`)."""
     mux = mux or get_multiplexer()
     root = mux.registry_root()
+    if root is None:
+        return []
     try:
-        if root is None or Path(root) != mux_registry_root(project):
-            return []
+        derived = mux_registry_root(project)
         old = mux.session_name_key(superseded_ctl_name(project))
     except (StateRootError, OSError, RuntimeError):
         return []
+    try:
+        own = os.path.normcase(str(Path(root).resolve())) == os.path.normcase(
+            str(derived.resolve())
+        )
+    except (OSError, RuntimeError) as exc:
+        own = Path(root) == derived
+        if on_fault is not None:
+            on_fault(f"could not resolve the registry root, compared as spelled: {exc}")
+    if not own:
+        return []
     return sorted(
         name
         for name in mux.list_sessions_reporting(on_fault=on_fault)
diff --git a/tests/test_runs.py b/tests/test_runs.py
index db3d5cad..d9714a98 100644
--- a/tests/test_runs.py
+++ b/tests/test_runs.py
@@ -9016,6 +9016,48 @@ def test_superseded_ctl_sessions_claims_nothing_outside_our_own_registry(tmp_pat
     assert runs.superseded_ctl_sessions(tmp_path, mux) == []
 
 
+def test_superseded_ctl_sessions_follows_an_alias_of_our_own_registry(tmp_path):
+    """An honoured operator root that is a symlink or junction to this project's
+    derived registry is that registry: the old mint resolved both and gave it
+    the derived root's name. Compared as spelled, the alias reads as somebody
+    else's root and the old control session goes unnamed. Ablate the resolved
+    comparison in `superseded_ctl_sessions` back to `Path(root) == derived` and
+    this fails."""
+    derived = runs.mux_registry_root(tmp_path)
+    derived.mkdir(parents=True, exist_ok=True)
+    alias = tmp_path / "alias-mux"
+    if sys.platform == "win32":
+        import _winapi  # Windows-only stdlib module; a junction needs no privilege
+
+        _winapi.CreateJunction(str(derived), str(alias))
+    else:
+        alias.symlink_to(derived, target_is_directory=True)
+    old = runs.superseded_ctl_name(tmp_path)
+    mux = _RegistryMux([runs.CTL_SESSION, old], {}, root=str(alias))
+    assert runs.superseded_ctl_sessions(tmp_path, mux) == [old]
+
+
+def test_superseded_ctl_sessions_says_when_it_compared_the_root_as_spelled(tmp_path, monkeypatch):
+    """A registry root that cannot be resolved keeps the as-spelled comparison
+    and never raises, but the degrade is reported, not folded into a clean
+    answer. Ablate the `on_fault` report, or the as-spelled fallback, and this
+    fails."""
+    root = str(runs.mux_registry_root(tmp_path))
+    monkeypatch.setattr(runs, "superseded_ctl_name", lambda _p: _DIGEST_CTL)
+    real_resolve = Path.resolve
+
+    def _resolve(self, strict=False):
+        if str(self) == root:
+            raise OSError("symlink loop")
+        return real_resolve(self, strict)
+
+    monkeypatch.setattr(Path, "resolve", _resolve)
+    faults: list[str] = []
+    mux = _RegistryMux([_DIGEST_CTL], {}, root=root)
+    assert runs.superseded_ctl_sessions(tmp_path, mux, on_fault=faults.append) == [_DIGEST_CTL]
+    assert faults == ["could not resolve the registry root, compared as spelled: symlink loop"]
+
+
 def test_legacy_leftovers_name_a_pre_rename_control_session_in_our_own_registry(
     tmp_path, monkeypatch
 ):

From 170c36e9cc6a1e3c862a5169ade74e744625e1ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Davor=20Raci=C4=87?= <davor.racic@gmail.com>
Date: Wed, 14 Oct 2026 09:29:32 +0200
Subject: [PATCH 04/11] fix(cleanup): find a pre-upgrade control session in an
 honoured registry root

With [mux] honor_ambient_psmux_data_dir keeping an operator's own root,
the previous release salted the control-session digest with that root, so
the session there carries a name the derived registry's never matched.
Derive the name for the registry in force with that release's formula,
salt included, and match it there: either digest covers this project's
derived root, so the session is this project's wherever it stands.

A root that cannot be derived or resolved is no longer an empty answer:
the fault goes to on_fault, which cleanup lists under legacy_unverified and
attach prints as a note.

Refs #733
---
 src/bmad_loop/cli.py  | 20 ++++++-----
 src/bmad_loop/runs.py | 66 +++++++++++++++++------------------
 tests/test_cli.py     |  2 +-
 tests/test_runs.py    | 80 +++++++++++++++++++++++++++++--------------
 4 files changed, 99 insertions(+), 69 deletions(-)

diff --git a/src/bmad_loop/cli.py b/src/bmad_loop/cli.py
index a12bd2d2..1e7fe194 100644
--- a/src/bmad_loop/cli.py
+++ b/src/bmad_loop/cli.py
@@ -6715,24 +6715,28 @@ def _psmux_command(registry: str | None, verb: str) -> str:
 
 
 def _superseded_ctl_kill_commands(project: Path, leftovers: dict[str, list[str]]) -> dict[str, str]:
-    """``{name: command that ends it}`` for each control session in this
-    project's own registry under a name this release no longer mints (#733),
-    picked out of ``leftovers`` rather than listed a second time.
+    """``{name: command that ends it}`` for each control session in the
+    registry in force under the name an earlier release minted for this
+    project there (#733, ``runs.superseded_ctl_name``), picked out of
+    ``leftovers`` rather than listed a second time.
 
     A command here and none for the other leftovers, because this session is
-    ours beyond doubt — the registry is the project's own — and nothing else
-    will ever end it: no bmad-loop command addresses it. The caveat travels
-    with the command: ending it kills whatever its windows still run."""
+    ours beyond doubt — its name is a digest of this project's derived root —
+    and nothing else will ever end it: no bmad-loop command addresses it. The
+    caveat travels with the command: ending it kills whatever its windows
+    still run."""
     if not leftovers:
         return {}
     from .adapters.multiplexer import MultiplexerError, get_multiplexer
 
     try:
         mux = get_multiplexer()
-        old = mux.session_name_key(runs.superseded_ctl_name(project))
+        root = mux.registry_root()
+        old = mux.session_name_key(runs.superseded_ctl_name(project, root))
     except (MultiplexerError, runs.StateRootError, OSError, RuntimeError):
+        # Already reported: the same derivation in `legacy_registry_leftovers`
+        # put this fault in `legacy_unverified`, and named no session for it.
         return {}
-    root = mux.registry_root()
     # The exact name `runs.superseded_ctl_sessions` matched, never the shape: a
     # run's agent session `bmad-loop-ctl-<16 hex>` is spelled the same way.
     return {
diff --git a/src/bmad_loop/runs.py b/src/bmad_loop/runs.py
index 9b026453..6cdef1eb 100644
--- a/src/bmad_loop/runs.py
+++ b/src/bmad_loop/runs.py
@@ -2541,19 +2541,26 @@ def legacy_registry_leftovers(
     return grouped, faults
 
 
-def superseded_ctl_name(project: Path) -> str:
-    """The control-session name an earlier release minted for ``project`` in its
-    own derived registry (#733): ``bmad-loop-ctl-`` plus the first 16 hex of the
-    SHA-256 of that root, resolved and case-folded where the filesystem folds.
-
-    The formula that release used, kept verbatim for this one reader. Its
-    honoured-operator-root arm salted the digest with that root too, but
-    :func:`superseded_ctl_sessions` only reads the derived registry, where the
-    salt was never added.
-
-    Raises :class:`StateRootError` or ``OSError`` when the root cannot be
-    derived."""
+def superseded_ctl_name(project: Path, registry: str | None = None) -> str:
+    """The control-session name an earlier release minted for ``project`` in
+    ``registry``, the root the backend was bound to (#733): ``bmad-loop-ctl-``
+    plus the first 16 hex of the SHA-256 of the project's derived root, resolved
+    and case-folded where the filesystem folds.
+
+    The formula that release used, kept verbatim for this one reader. When
+    ``registry`` is an absolute root that resolves to a different registry (an
+    operator's own root honoured by ``[mux] honor_ambient_psmux_data_dir``), the
+    digest is salted with it too; a symlink, junction or other spelling of the
+    derived root resolves to it and is not salted.
+
+    Raises :class:`StateRootError`, ``OSError`` or ``RuntimeError`` when a root
+    cannot be derived or resolved. That release then minted the fixed name, so
+    no digest-named session can exist for it."""
     scope = os.path.normcase(str(mux_registry_root(project).resolve()))
+    if registry and Path(registry).is_absolute():
+        pinned = os.path.normcase(str(Path(registry).resolve()))
+        if pinned != scope:
+            scope += "\0" + pinned
     return f"{CTL_SESSION}-{hashlib.sha256(os.fsencode(scope)).hexdigest()[:16]}"
 
 
@@ -2576,36 +2583,25 @@ def superseded_ctl_sessions(
     name (:func:`is_ctl_session_name`). A run window parked in one is reached by
     no command, so this is what the cleanup and attach frontends name.
 
-    Only when the registry in force is this project's derived one
-    (:func:`mux_registry_root`): a control session in it is this project's.
-    psmux's shared default registry, an operator's own root, and a
-    machine-wide server (tmux, which never minted the digest shape) prove
-    nothing about whose a session spelled that way is. Compared as the old mint
-    compared them, resolved and then case-folded: an honoured root that is a
-    symlink, junction or other spelling of the derived one is that registry,
-    and the old mint gave it the same name. A root that cannot be resolved is
-    compared as spelled, and that degrade goes to ``on_fault``.
-
-    A listing that could not be taken goes to ``on_fault`` and answers ``[]``
+    The name is the registry's own: unsalted in this project's derived
+    registry (or any spelling of it), salted with the root in an operator's
+    root honoured over it. Either digest covers this project's derived root, so
+    a session under it is this project's wherever it stands. psmux's shared
+    default registry (no root) and a machine-wide server (tmux, which never
+    minted the digest shape) are not read.
+
+    A name that could not be derived, and a listing that could not be taken,
+    go to ``on_fault`` and answer ``[]``
     (:meth:`~.multiplexer.TerminalMultiplexer.list_sessions_reporting`)."""
     mux = mux or get_multiplexer()
     root = mux.registry_root()
     if root is None:
         return []
     try:
-        derived = mux_registry_root(project)
-        old = mux.session_name_key(superseded_ctl_name(project))
-    except (StateRootError, OSError, RuntimeError):
-        return []
-    try:
-        own = os.path.normcase(str(Path(root).resolve())) == os.path.normcase(
-            str(derived.resolve())
-        )
-    except (OSError, RuntimeError) as exc:
-        own = Path(root) == derived
+        old = mux.session_name_key(superseded_ctl_name(project, root))
+    except (StateRootError, OSError, RuntimeError) as exc:
         if on_fault is not None:
-            on_fault(f"could not resolve the registry root, compared as spelled: {exc}")
-    if not own:
+            on_fault(f"could not derive the pre-upgrade control-session name: {exc}")
         return []
     return sorted(
         name
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 2224d396..eee8b68e 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -19720,7 +19720,7 @@ def test_cleanup_prints_the_kill_command_for_a_pre_upgrade_control_session(
     )
     monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
     monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OwnRegistryMux())
-    monkeypatch.setattr(runs, "superseded_ctl_name", lambda _p: _DIGEST_CTL)
+    monkeypatch.setattr(runs, "superseded_ctl_name", lambda _p, _r=None: _DIGEST_CTL)
     command = f"$env:PSMUX_DATA_DIR = '{_OWN_REG}'; psmux kill-session -t '={_DIGEST_CTL}'"
 
     assert cli.main(["cleanup", "--dry-run", "--project", str(project.project)]) == 0
diff --git a/tests/test_runs.py b/tests/test_runs.py
index d9714a98..0de615a8 100644
--- a/tests/test_runs.py
+++ b/tests/test_runs.py
@@ -9000,17 +9000,39 @@ def test_superseded_ctl_name_is_the_previous_releases_mint(tmp_path):
     derivation or the hashing fails."""
     import hashlib
 
-    scope = os.path.normcase(str(runs.mux_registry_root(tmp_path).resolve()))
+    derived = runs.mux_registry_root(tmp_path)
+    scope = os.path.normcase(str(derived.resolve()))
     digest = hashlib.sha256(os.fsencode(scope)).hexdigest()[:16]
     assert runs.superseded_ctl_name(tmp_path) == f"{runs.CTL_SESSION}-{digest}"
+    assert runs.superseded_ctl_name(tmp_path, str(derived)) == f"{runs.CTL_SESSION}-{digest}"
+    # An honoured operator root that is another registry salts the digest.
+    honoured = tmp_path / "operator-reg"
+    salted = scope + "\0" + os.path.normcase(str(honoured.resolve()))
+    salted_digest = hashlib.sha256(os.fsencode(salted)).hexdigest()[:16]
+    assert runs.superseded_ctl_name(tmp_path, str(honoured)) == (
+        f"{runs.CTL_SESSION}-{salted_digest}"
+    )
+
+
+def test_superseded_ctl_sessions_names_the_salted_name_in_an_honoured_root(tmp_path):
+    """With `[mux] honor_ambient_psmux_data_dir` keeping an operator's own root,
+    the previous release minted the control session there under a digest salted
+    with that root. That name, and not the derived registry's, is the one to
+    find there. Ablate the root handed to `superseded_ctl_name` in
+    `superseded_ctl_sessions` and this fails."""
+    honoured = str(tmp_path / "operator-reg")
+    salted = runs.superseded_ctl_name(tmp_path, honoured)
+    unsalted = runs.superseded_ctl_name(tmp_path)
+    assert salted != unsalted
+    mux = _RegistryMux([runs.CTL_SESSION, unsalted, salted, _DIGEST_CTL], {}, root=honoured)
+    assert runs.superseded_ctl_sessions(tmp_path, mux) == [salted]
 
 
 @pytest.mark.parametrize("root", [None, "elsewhere"])
-def test_superseded_ctl_sessions_claims_nothing_outside_our_own_registry(tmp_path, root):
-    """psmux's shared default registry (`None`) and any root that is not this
-    project's derived one hold sessions of other projects and of the operator:
-    a digest-named control session there proves nothing about whose it is.
-    Ablate the `own` check in `superseded_ctl_sessions` and this fails."""
+def test_superseded_ctl_sessions_names_no_other_digest(tmp_path, root):
+    """psmux's shared default registry (`None`) is not read at all, and in any
+    other root only this project's exact name is: a digest-named session that
+    is not it proves nothing about whose it is."""
     reg = None if root is None else str(tmp_path / root)
     mux = _RegistryMux([_DIGEST_CTL], {}, root=reg)
     assert runs.superseded_ctl_sessions(tmp_path, mux) == []
@@ -9019,10 +9041,9 @@ def test_superseded_ctl_sessions_claims_nothing_outside_our_own_registry(tmp_pat
 def test_superseded_ctl_sessions_follows_an_alias_of_our_own_registry(tmp_path):
     """An honoured operator root that is a symlink or junction to this project's
     derived registry is that registry: the old mint resolved both and gave it
-    the derived root's name. Compared as spelled, the alias reads as somebody
-    else's root and the old control session goes unnamed. Ablate the resolved
-    comparison in `superseded_ctl_sessions` back to `Path(root) == derived` and
-    this fails."""
+    the derived root's name, unsalted. Compared as spelled, the alias reads as
+    another registry and the name to find goes salted. Ablate the `resolve()`
+    of the registry in `superseded_ctl_name` and this fails."""
     derived = runs.mux_registry_root(tmp_path)
     derived.mkdir(parents=True, exist_ok=True)
     alias = tmp_path / "alias-mux"
@@ -9037,25 +9058,34 @@ def test_superseded_ctl_sessions_follows_an_alias_of_our_own_registry(tmp_path):
     assert runs.superseded_ctl_sessions(tmp_path, mux) == [old]
 
 
-def test_superseded_ctl_sessions_says_when_it_compared_the_root_as_spelled(tmp_path, monkeypatch):
-    """A registry root that cannot be resolved keeps the as-spelled comparison
-    and never raises, but the degrade is reported, not folded into a clean
-    answer. Ablate the `on_fault` report, or the as-spelled fallback, and this
-    fails."""
-    root = str(runs.mux_registry_root(tmp_path))
-    monkeypatch.setattr(runs, "superseded_ctl_name", lambda _p: _DIGEST_CTL)
-    real_resolve = Path.resolve
+@pytest.mark.parametrize("fails", ["registry", "derived"])
+def test_superseded_ctl_sessions_reports_a_name_it_could_not_derive(tmp_path, monkeypatch, fails):
+    """The registry in force, or this project's derived root, could not be
+    resolved, so the name cannot be derived. It never raises, and the fault is
+    reported rather than folded into a clean "no such session". Ablate the
+    `on_fault` report in `superseded_ctl_sessions` and this fails."""
+    root = str(tmp_path / "operator-reg")
+    if fails == "derived":
 
-    def _resolve(self, strict=False):
-        if str(self) == root:
-            raise OSError("symlink loop")
-        return real_resolve(self, strict)
+        def _no_root(_p):
+            raise runs.StateRootError("no writable state root")
 
-    monkeypatch.setattr(Path, "resolve", _resolve)
+        monkeypatch.setattr(runs, "mux_registry_root", _no_root)
+        detail = "no writable state root"
+    else:
+        real_resolve = Path.resolve
+
+        def _resolve(self, strict=False):
+            if str(self) == root:
+                raise OSError("symlink loop")
+            return real_resolve(self, strict)
+
+        monkeypatch.setattr(Path, "resolve", _resolve)
+        detail = "symlink loop"
     faults: list[str] = []
     mux = _RegistryMux([_DIGEST_CTL], {}, root=root)
-    assert runs.superseded_ctl_sessions(tmp_path, mux, on_fault=faults.append) == [_DIGEST_CTL]
-    assert faults == ["could not resolve the registry root, compared as spelled: symlink loop"]
+    assert runs.superseded_ctl_sessions(tmp_path, mux, on_fault=faults.append) == []
+    assert faults == [f"could not derive the pre-upgrade control-session name: {detail}"]
 
 
 def test_legacy_leftovers_name_a_pre_rename_control_session_in_our_own_registry(

From bed31eef9f54be6f2657a2189cbf3864ee6a34f8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Davor=20Raci=C4=87?= <davor.racic@gmail.com>
Date: Wed, 14 Oct 2026 10:43:05 +0200
Subject: [PATCH 05/11] fix(cleanup): print a pre-upgrade control session's
 command only on psmux

The recovery commands for a superseded control session were always spelled
as psmux PowerShell lines, so an out-of-tree registry-namespaced backend got
a command that fails there or reaches the wrong registry. Print the
paste-ready command only when the selected backend is psmux; on any other
backend name the session without one, in the cleanup text, as a null in
sessions.legacy_kill_commands, and in the attach note.

Refs #733
---
 docs/reference/cli.md      |  2 +-
 src/bmad_loop/cli.py       | 45 +++++++++++++++-------
 src/bmad_loop/documents.py | 10 +++--
 tests/test_cli.py          | 78 ++++++++++++++++++++++++++++++++++----
 4 files changed, 110 insertions(+), 25 deletions(-)

diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index c680fa1e..595b3d15 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -546,7 +546,7 @@ The `--dry-run` plan and the outcome share this shape.
 | `sessions`    | object | agent sessions (below)         |
 | `ctl_windows` | object | control windows (below)        |
 
-`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_kill_commands` (a pre-upgrade control session in this project's registry mapped to the command that ends it), `legacy_unverified`, and `scan_error` (present only when the scan failed).
+`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_kill_commands` (a pre-upgrade control session in this project's registry mapped to the command that ends it, `null` when the backend is not psmux), `legacy_unverified`, and `scan_error` (present only when the scan failed).
 
 `ctl_windows`: `removed` (verified gone, or would close under `--dry-run`), `survived`, `unverifiable` (kill outcome could not be checked), `undetermined` (kept because the window's state could not be read), `scan_error` (str or null; when set, the other lists mean "no answer").
 
diff --git a/src/bmad_loop/cli.py b/src/bmad_loop/cli.py
index 1e7fe194..4c35e9b9 100644
--- a/src/bmad_loop/cli.py
+++ b/src/bmad_loop/cli.py
@@ -6449,7 +6449,10 @@ def _note_superseded_ctl_for_attach(project: Path) -> None:
     The verb is the one attach itself would run here: inside a multiplexer
     client a nested attach is refused, so the backend switches the client
     instead (``attach_target_argv``). A listing that could not be taken is said,
-    not passed off as "no such session" after "nothing to attach"."""
+    not passed off as "no such session" after "nothing to attach".
+
+    A paste-ready command only on psmux (``_is_psmux``); another backend's
+    session is named without one."""
     from .adapters.multiplexer import MultiplexerError, get_multiplexer
 
     def _fault(msg: str) -> None:
@@ -6465,13 +6468,15 @@ def _fault(msg: str) -> None:
     except MultiplexerError as exc:
         _fault(str(exc))
         return
+    psmux = _is_psmux(mux)
     for name in stale:
-        verb = mux.attach_target_argv(f"={name}")[1]
-        command = _psmux_command(mux.registry_root(), f"{verb} -t '={name}'")
+        where = "this run's window may be there"
+        if psmux:
+            verb = mux.attach_target_argv(f"={name}")[1]
+            where += ": " + _psmux_command(mux.registry_root(), f"{verb} -t '={name}'")
         print(
             f"note: pre-upgrade control session {name} is still running in this "
-            f"project's registry, and attach does not look inside it; this run's "
-            f"window may be there: {command}",
+            f"project's registry, and attach does not look inside it; {where}",
             file=sys.stderr,
         )
 
@@ -6701,12 +6706,20 @@ def cmd_archive(args: argparse.Namespace) -> int:
     return 0
 
 
+def _is_psmux(mux: object) -> bool:
+    """Whether ``mux`` is the bundled psmux backend, the one transport whose
+    commands :func:`_psmux_command` can spell. ponytail: no generic renderer;
+    an out-of-tree registry-namespaced backend gets its sessions named, not a
+    command, until one needs more."""
+    from .adapters.psmux_backend import PsmuxMultiplexer
+
+    return isinstance(mux, PsmuxMultiplexer)
+
+
 def _psmux_command(registry: str | None, verb: str) -> str:
     """A paste-ready PowerShell line running ``psmux <verb>`` against
     ``registry`` (psmux's own default when ``None``). Quoted the way
-    ``_mux_info`` quotes its export line. ponytail: psmux is the only bundled
-    transport with a registry namespace, which is the only place the
-    sessions this spells a command for can exist."""
+    ``_mux_info`` quotes its export line. psmux only (:func:`_is_psmux`)."""
     run = f"psmux {verb}"
     if registry is None:
         return run
@@ -6714,7 +6727,9 @@ def _psmux_command(registry: str | None, verb: str) -> str:
     return f"$env:{runs.PSMUX_DATA_DIR} = '{quoted}'; {run}"
 
 
-def _superseded_ctl_kill_commands(project: Path, leftovers: dict[str, list[str]]) -> dict[str, str]:
+def _superseded_ctl_kill_commands(
+    project: Path, leftovers: dict[str, list[str]]
+) -> dict[str, str | None]:
     """``{name: command that ends it}`` for each control session in the
     registry in force under the name an earlier release minted for this
     project there (#733, ``runs.superseded_ctl_name``), picked out of
@@ -6724,7 +6739,9 @@ def _superseded_ctl_kill_commands(project: Path, leftovers: dict[str, list[str]]
     ours beyond doubt — its name is a digest of this project's derived root —
     and nothing else will ever end it: no bmad-loop command addresses it. The
     caveat travels with the command: ending it kills whatever its windows
-    still run."""
+    still run. ``None`` for the command when the backend is not psmux
+    (:func:`_is_psmux`): the session is named, and no command is advertised
+    that could not run there."""
     if not leftovers:
         return {}
     from .adapters.multiplexer import MultiplexerError, get_multiplexer
@@ -6739,20 +6756,22 @@ def _superseded_ctl_kill_commands(project: Path, leftovers: dict[str, list[str]]
         return {}
     # The exact name `runs.superseded_ctl_sessions` matched, never the shape: a
     # run's agent session `bmad-loop-ctl-<16 hex>` is spelled the same way.
+    psmux = _is_psmux(mux)
     return {
-        name: _psmux_command(root, f"kill-session -t '={name}'")
+        name: _psmux_command(root, f"kill-session -t '={name}'") if psmux else None
         for name in leftovers.get(root or runs.DEFAULT_REGISTRY_LABEL, [])
         if mux.session_name_key(name) == old
     }
 
 
-def _warn_superseded_ctl(kill_commands: dict[str, str]) -> None:
+def _warn_superseded_ctl(kill_commands: dict[str, str | None]) -> None:
     for name, command in kill_commands.items():
+        how = f"end it with: {command}" if command else "end it with your multiplexer"
         print(
             f"pre-upgrade control session {name} is still running in this project's "
             "registry, and no bmad-loop command addresses it; once its runs have "
             "finished and every window in it shows the exit banner (ending it kills "
-            f"what they still run), end it with: {command}",
+            f"what they still run), {how}",
             file=sys.stderr,
         )
 
diff --git a/src/bmad_loop/documents.py b/src/bmad_loop/documents.py
index 9c118deb..4ef5dd51 100644
--- a/src/bmad_loop/documents.py
+++ b/src/bmad_loop/documents.py
@@ -397,7 +397,7 @@ def cleanup_document(
     windows_undetermined: list[str] | None = None,
     legacy_leftovers: list[str] | None = None,
     legacy_unverified: list[str] | None = None,
-    legacy_kill_commands: dict[str, str] | None = None,
+    legacy_kill_commands: dict[str, str | None] | None = None,
     sessions_scan_error: str | None = None,
 ) -> dict[str, object]:
     """The `cleanup --json` document: the multiplexer artifacts this invocation
@@ -461,9 +461,11 @@ def cleanup_document(
 
     `sessions.legacy_kill_commands` maps each pre-upgrade control session in
     this project's own registry (#733) — also named in `legacy_leftovers` — to
-    the paste-ready command that ends it. No bmad-loop command addresses such a
-    session, so this is the only way out; run it once every window in it has
-    parked. Additive, no schema bump; the text mode prints each on stderr.
+    the paste-ready command that ends it, or to ``null`` when the backend is
+    not psmux and no command can be spelled for it. No bmad-loop command
+    addresses such a session, so this is the only way out; run it once every
+    window in it has parked. Additive, no schema bump; the text mode prints each
+    on stderr.
 
     `sessions.scan_error` is present only when the session listing could not
     see this project's sessions (#864): the backend is unavailable while a run
diff --git a/tests/test_cli.py b/tests/test_cli.py
index eee8b68e..6ddc4477 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -2897,13 +2897,11 @@ def test_attach_nothing_to_attach(project, monkeypatch, capsys):
 _OWN_REG = r"C:\state\0123456789abcdef\_mux"
 
 
-class _OwnRegistryMux:
-    """The primary backend as the #733 readers see it: bound to this project's
-    registry, which holds a control session under the pre-rename digest name."""
-
-    _BINARY = "psmux"
-    # The real client verb choice, so the printed command follows it.
-    attach_target_argv = PsmuxMultiplexer.attach_target_argv
+class _OwnRegistryMux(PsmuxMultiplexer):
+    """The primary backend as the #733 readers see it: psmux, bound to this
+    project's registry, which holds a control session under the pre-rename
+    digest name. A real `PsmuxMultiplexer` subclass, so the client verb is the
+    backend's own and the paste-ready command is psmux's."""
 
     def has_registry_namespace(self):
         return False  # keeps `_configure_mux` from exporting a root over this fake
@@ -2915,6 +2913,43 @@ def session_name_key(self, name):
         return name
 
 
+class _OtherRegistryMux:
+    """An out-of-tree registry-namespaced backend holding the same session: not
+    psmux, so no psmux command may be printed for it."""
+
+    def has_registry_namespace(self):
+        return False
+
+    def registry_root(self):
+        return _OWN_REG
+
+    def session_name_key(self, name):
+        return name
+
+    def attach_target_argv(self, target):
+        return ["othermux", "attach", "-t", target]
+
+
+def test_attach_names_a_pre_upgrade_control_session_without_a_command_off_psmux(
+    project, monkeypatch, capsys
+):
+    """On a backend that is not psmux the session is still named, but no psmux
+    PowerShell line is advertised: it would fail there, or reach the wrong
+    registry. Ablate `_is_psmux` (answer True) and this fails."""
+    from bmad_loop.tui import launch
+
+    _make_run_with_decision(project, run_id="20260101-000000-aaaa")
+    monkeypatch.setattr(launch, "attach_plan", lambda proj, rid, **_kw: (None, 0))
+    monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OtherRegistryMux())
+    monkeypatch.setattr(runs, "superseded_ctl_sessions", lambda _p, _m=None, **_kw: [_DIGEST_CTL])
+
+    assert cli.main(["attach", "--project", str(project.project), "20260101-000000-aaaa"]) == 1
+    err = capsys.readouterr().err
+    assert f"pre-upgrade control session {_DIGEST_CTL} is still running" in err
+    assert "this run's window may be there\n" in err
+    assert "psmux" not in err and "PSMUX_DATA_DIR" not in err
+
+
 def test_attach_names_a_pre_upgrade_control_session_it_cannot_see_into(
     project, monkeypatch, capsys
 ):
@@ -19691,6 +19726,35 @@ def test_cleanup_says_nothing_about_a_registry_with_no_remainder(project, capsys
     assert "not migrated" not in err and "not checked" not in err
 
 
+def test_cleanup_names_a_pre_upgrade_control_session_without_a_command_off_psmux(
+    project, capsys, monkeypatch
+):
+    """Off psmux the session is still named, in text and in --json, but its
+    command is `null` and the text line advertises none. Ablate `_is_psmux`
+    (answer True) and this fails."""
+    from bmad_loop.tui import launch
+
+    monkeypatch.setattr(runs, "prune_sessions", lambda _p, dry_run=False: ([], [], set()))
+    monkeypatch.setattr(
+        runs,
+        "legacy_registry_leftovers",
+        lambda _p, announced=(): ({_OWN_REG: [_DIGEST_CTL]}, []),
+    )
+    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
+    monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OtherRegistryMux())
+    monkeypatch.setattr(runs, "superseded_ctl_name", lambda _p, _r=None: _DIGEST_CTL)
+
+    assert cli.main(["cleanup", "--project", str(project.project)]) == 0
+    err = capsys.readouterr().err
+    assert f"pre-upgrade control session {_DIGEST_CTL}" in err
+    assert "end it with your multiplexer" in err
+    assert "psmux" not in err and "PSMUX_DATA_DIR" not in err
+
+    assert cli.main(["cleanup", "--json", "--project", str(project.project)]) == 0
+    doc = json.loads(capsys.readouterr().out)
+    assert doc["sessions"]["legacy_kill_commands"] == {_DIGEST_CTL: None}
+
+
 def test_cleanup_prints_the_kill_command_for_a_pre_upgrade_control_session(
     project, capsys, monkeypatch
 ):

From 01ab7ee9f66e48a10fd472ab3ed022b4bc4085d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Davor=20Raci=C4=87?= <davor.racic@gmail.com>
Date: Wed, 14 Oct 2026 13:12:24 +0200
Subject: [PATCH 06/11] fix(cleanup): withhold a pre-upgrade control session's
 command when a run may own it

A run whose id equals the old control-session digest owns bmad-loop-<id>,
the same name an earlier release minted for the control session. cleanup
and attach now name such a session with no kill or attach command, and a
runs dir that cannot be read for that check withholds it too and is
reported.

legacy_registry_leftovers also scans the project's own registry when
legacy-registry discovery raises, keeping both the primary leftovers and
the discovery fault.

Closes #915
---
 CHANGELOG.md                 |   3 +
 docs/multiplexer-backends.md |  12 ++--
 docs/reference/cli.md        |   2 +-
 src/bmad_loop/cli.py         |  73 +++++++++++++++++------
 src/bmad_loop/documents.py   |   7 ++-
 src/bmad_loop/runs.py        |  43 +++++++++++++-
 tests/test_cli.py            | 112 +++++++++++++++++++++++++++++++++++
 tests/test_runs.py           |  52 ++++++++++++++++
 8 files changed, 277 insertions(+), 27 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 37bf82e6..c63074d0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -97,6 +97,9 @@ breaking changes may land in a minor release.
   psmux registry: `cleanup` names it on stderr and in `sessions.legacy_leftovers` with the
   command that ends it (`sessions.legacy_kill_commands`), and `attach` names it when it finds
   nothing to attach (#733).
+- Print no kill or attach command for a pre-upgrade control-session name that a run of this
+  project has as its id (it may be that run's own session), and still check the project's own
+  registry when legacy-registry discovery fails (#915).
 - Fire the TUI's stale state-root note on psmux too: the psmux backend now answers which
   value a new pane inherits through psmux 3.4.0's named `show-environment` (#660).
 - Fix the OpenCode V2 SSE-reconnect end-to-end test failing on slow runners (Windows): the
diff --git a/docs/multiplexer-backends.md b/docs/multiplexer-backends.md
index 6ff1c344..7e72c224 100644
--- a/docs/multiplexer-backends.md
+++ b/docs/multiplexer-backends.md
@@ -137,12 +137,14 @@ prunes it. Nothing launches into it, though, so the TUI's attach and stop keys a
 parked-window sweep do not reach its windows. To end one, let its runs finish
 (`bmad-loop stop` reaches a live engine wherever it runs) and check that every window shows
 the exit banner (see `capture-pane` below). Then run
-`psmux kill-session -t bmad-loop-ctl-<16 hex>`. `cleanup` names the one an earlier release
-started for this project in its registry (matched by that exact name, since a run id
-`ctl-<16 hex>` gives an agent session the same shape) on stderr and in
-`sessions.legacy_leftovers`, with that command ready to paste
+`psmux kill-session -t bmad-loop-ctl-<16 hex>`.
+
+`cleanup` names the one an earlier release started for this project in its registry
+(matched by that exact name, since a run id `ctl-<16 hex>` gives an agent session the same
+shape) on stderr and in `sessions.legacy_leftovers`, with that command ready to paste
 (`sessions.legacy_kill_commands` in `--json`). `attach` names it when it finds nothing to
-attach, with `switch-client` instead of `attach` when run inside a psmux pane.
+attach, with `switch-client` instead of `attach` when run inside a psmux pane. A name a run
+of this project has as its id may be that run's own session, so it is named with no command.
 
 **If the state root cannot be derived** (for example, `BMAD_LOOP_STATE_DIR` is a relative
 path), bmad-loop says so and leaves whatever `PSMUX_DATA_DIR` was in force. `cleanup` then
diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index 595b3d15..e7b2e958 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -546,7 +546,7 @@ The `--dry-run` plan and the outcome share this shape.
 | `sessions`    | object | agent sessions (below)         |
 | `ctl_windows` | object | control windows (below)        |
 
-`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_kill_commands` (a pre-upgrade control session in this project's registry mapped to the command that ends it, `null` when the backend is not psmux), `legacy_unverified`, and `scan_error` (present only when the scan failed).
+`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_kill_commands` (a pre-upgrade control session in this project's registry mapped to the command that ends it, `null` when the backend is not psmux; a session a run of this project may own is left out), `legacy_unverified`, and `scan_error` (present only when the scan failed).
 
 `ctl_windows`: `removed` (verified gone, or would close under `--dry-run`), `survived`, `unverifiable` (kill outcome could not be checked), `undetermined` (kept because the window's state could not be read), `scan_error` (str or null; when set, the other lists mean "no answer").
 
diff --git a/src/bmad_loop/cli.py b/src/bmad_loop/cli.py
index 4c35e9b9..a814e191 100644
--- a/src/bmad_loop/cli.py
+++ b/src/bmad_loop/cli.py
@@ -6452,7 +6452,8 @@ def _note_superseded_ctl_for_attach(project: Path) -> None:
     not passed off as "no such session" after "nothing to attach".
 
     A paste-ready command only on psmux (``_is_psmux``); another backend's
-    session is named without one."""
+    session is named without one, and so is a name a run of this project may
+    own (``runs.superseded_ctl_may_be_run``, #915)."""
     from .adapters.multiplexer import MultiplexerError, get_multiplexer
 
     def _fault(msg: str) -> None:
@@ -6470,6 +6471,17 @@ def _fault(msg: str) -> None:
         return
     psmux = _is_psmux(mux)
     for name in stale:
+        if runs.superseded_ctl_may_be_run(
+            project, name, mux, on_fault=lambda msg: print(f"note: {msg}", file=sys.stderr)
+        ):
+            # #915: no attach command into what may be a run's own session.
+            print(
+                f"note: pre-upgrade control session {name} is still running in this "
+                f"project's registry, and attach does not look inside it; {_MAY_BE_RUN} "
+                "and no command is printed for it",
+                file=sys.stderr,
+            )
+            continue
         where = "this run's window may be there"
         if psmux:
             verb = mux.attach_target_argv(f"={name}")[1]
@@ -6728,10 +6740,10 @@ def _psmux_command(registry: str | None, verb: str) -> str:
 
 
 def _superseded_ctl_kill_commands(
-    project: Path, leftovers: dict[str, list[str]]
-) -> dict[str, str | None]:
-    """``{name: command that ends it}`` for each control session in the
-    registry in force under the name an earlier release minted for this
+    project: Path, leftovers: dict[str, list[str]], on_fault: Callable[[str], None]
+) -> tuple[dict[str, str | None], list[str]]:
+    """``({name: command that ends it}, ambiguous)`` for each control session
+    in the registry in force under the name an earlier release minted for this
     project there (#733, ``runs.superseded_ctl_name``), picked out of
     ``leftovers`` rather than listed a second time.
 
@@ -6741,9 +6753,15 @@ def _superseded_ctl_kill_commands(
     caveat travels with the command: ending it kills whatever its windows
     still run. ``None`` for the command when the backend is not psmux
     (:func:`_is_psmux`): the session is named, and no command is advertised
-    that could not run there."""
+    that could not run there.
+
+    ``ambiguous`` holds each such name a run of this project may own
+    (``runs.superseded_ctl_may_be_run``, #915): it gets no command at all, so
+    it is left out of the dict (and of ``--json`` ``legacy_kill_commands``)
+    while ``legacy_leftovers`` still names it. A runs dir that could not be
+    read for that check goes to ``on_fault``, labelled with the registry."""
     if not leftovers:
-        return {}
+        return {}, []
     from .adapters.multiplexer import MultiplexerError, get_multiplexer
 
     try:
@@ -6753,18 +6771,37 @@ def _superseded_ctl_kill_commands(
     except (MultiplexerError, runs.StateRootError, OSError, RuntimeError):
         # Already reported: the same derivation in `legacy_registry_leftovers`
         # put this fault in `legacy_unverified`, and named no session for it.
-        return {}
+        return {}, []
     # The exact name `runs.superseded_ctl_sessions` matched, never the shape: a
     # run's agent session `bmad-loop-ctl-<16 hex>` is spelled the same way.
     psmux = _is_psmux(mux)
-    return {
-        name: _psmux_command(root, f"kill-session -t '={name}'") if psmux else None
-        for name in leftovers.get(root or runs.DEFAULT_REGISTRY_LABEL, [])
-        if mux.session_name_key(name) == old
-    }
+    commands: dict[str, str | None] = {}
+    ambiguous: list[str] = []
+    label = root or runs.DEFAULT_REGISTRY_LABEL
+    for name in leftovers.get(label, []):
+        if mux.session_name_key(name) != old:
+            continue
+        if runs.superseded_ctl_may_be_run(
+            project, name, mux, on_fault=lambda msg: on_fault(f"{label}: {msg}")
+        ):
+            ambiguous.append(name)
+        else:
+            commands[name] = _psmux_command(root, f"kill-session -t '={name}'") if psmux else None
+    return commands, ambiguous
+
 
+#: Why a pre-upgrade control-session name gets no command (#915), said the
+#: same way by cleanup and attach.
+_MAY_BE_RUN = "a run of this project with that id may own it"
 
-def _warn_superseded_ctl(kill_commands: dict[str, str | None]) -> None:
+
+def _warn_superseded_ctl(kill_commands: dict[str, str | None], ambiguous: list[str]) -> None:
+    for name in ambiguous:
+        print(
+            f"pre-upgrade control session {name} is still running in this project's "
+            f"registry; {_MAY_BE_RUN} and no command is printed for it",
+            file=sys.stderr,
+        )
     for name, command in kill_commands.items():
         how = f"end it with: {command}" if command else "end it with your multiplexer"
         print(
@@ -6860,7 +6897,9 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
     leftovers, unverified = runs.legacy_registry_leftovers(
         project, announced=killed if args.dry_run else ()
     )
-    kill_commands = _superseded_ctl_kill_commands(project, leftovers)
+    kill_commands, ambiguous_ctl = _superseded_ctl_kill_commands(
+        project, leftovers, unverified.append
+    )
     # The listing behind prune_sessions reads an unavailable backend as no
     # sessions; this names the cases where that is not a clean answer (#864).
     # A misconfigured process host fails the liveness read behind it: a scan
@@ -6952,7 +6991,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
         if live:
             print(f"leaving {len(live)} live session(s) untouched")
         _warn_legacy_leftovers(project, leftovers, unverified)
-        _warn_superseded_ctl(kill_commands)
+        _warn_superseded_ctl(kill_commands, ambiguous_ctl)
         return 0
     # The count now excludes non-removals, so on stdout alone a smaller number is
     # indistinguishable from a quieter sweep — and `cleanup > log` keeps only
@@ -6971,7 +7010,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
         # moving between the two surfaces is reading the same thing.
         print(f"ctl window(s) still open after the kill: {', '.join(survived)}", file=sys.stderr)
     _warn_legacy_leftovers(project, leftovers, unverified)
-    _warn_superseded_ctl(kill_commands)
+    _warn_superseded_ctl(kill_commands, ambiguous_ctl)
     if unverifiable:
         # Not "killed but unverifiable": kill_window is a silent no-op on a
         # transport failure, so whether the kill even reached the server is part
diff --git a/src/bmad_loop/documents.py b/src/bmad_loop/documents.py
index 4ef5dd51..8a14d21a 100644
--- a/src/bmad_loop/documents.py
+++ b/src/bmad_loop/documents.py
@@ -464,8 +464,11 @@ def cleanup_document(
     the paste-ready command that ends it, or to ``null`` when the backend is
     not psmux and no command can be spelled for it. No bmad-loop command
     addresses such a session, so this is the only way out; run it once every
-    window in it has parked. Additive, no schema bump; the text mode prints each
-    on stderr.
+    window in it has parked. A session a run of this project may own (a run dir
+    exists for the id its name spells, #915) gets no command and is left out,
+    though `legacy_leftovers` still names it; a runs dir that could not be read
+    for that check withholds it too, and lands in `legacy_unverified`. Additive, no schema bump; the text
+    mode prints each on stderr.
 
     `sessions.scan_error` is present only when the session listing could not
     see this project's sessions (#864): the backend is unavailable while a run
diff --git a/src/bmad_loop/runs.py b/src/bmad_loop/runs.py
index 6cdef1eb..f2ab9e65 100644
--- a/src/bmad_loop/runs.py
+++ b/src/bmad_loop/runs.py
@@ -2487,9 +2487,16 @@ def legacy_registry_leftovers(
     excluded = {session_name(run_id) for run_id in announced}
     faults: list[str] = []
     try:
-        legacies = _legacy_registries()
+        primary = get_multiplexer()
     except MultiplexerError as exc:
         return grouped, [f"no legacy registry could be checked: backend selection failed: {exc}"]
+    # Its own try (#915): a legacy discovery that raises must not skip the
+    # primary-registry scan below, which needs only the backend selected above.
+    try:
+        legacies = _legacy_registries()
+    except MultiplexerError as exc:
+        faults.append(f"no legacy registry could be checked: {exc}")
+        legacies = []
     for legacy in legacies:
         try:
             names = legacy.list_sessions()
@@ -2527,7 +2534,6 @@ def legacy_registry_leftovers(
             grouped[label] = sorted(set(grouped.get(label, []) + here))
     # The project's own registry is no legacy one, but a control session an
     # earlier release named there survives the rename too (#733).
-    primary = get_multiplexer()
     label = primary.registry_root() or DEFAULT_REGISTRY_LABEL
     try:
         stale = superseded_ctl_sessions(
@@ -2610,6 +2616,39 @@ def superseded_ctl_sessions(
     )
 
 
+def superseded_ctl_may_be_run(
+    project: Path,
+    name: str,
+    mux: TerminalMultiplexer,
+    *,
+    on_fault: Callable[[str], None] | None = None,
+) -> bool:
+    """True when the pre-upgrade control-session name ``name`` (as listed) may
+    instead be the agent session of a run of ``project`` (#915).
+
+    A run id equal to the old digest, ``ctl-<16 hex>`` (one supplied by hand
+    or persisted by an older release), owns ``bmad-loop-<id>`` — the very name
+    the old release minted for the control session — so the name alone cannot
+    say which it is, and that run may be live. Any run dir whose session the
+    transport resolves to ``name`` (``mux``'s
+    :meth:`~.multiplexer.TerminalMultiplexer.session_name_key`, so a case
+    variant counts where the transport folds) is enough to withhold a kill or
+    attach command for it.
+
+    A runs dir that cannot be listed answers True, the direction that withholds
+    a command, and the fault goes to ``on_fault``."""
+    key = mux.session_name_key(name)
+    try:
+        entries = [entry.name for entry in (project / RUNS_DIR).iterdir()]
+    except (FileNotFoundError, NotADirectoryError):
+        return False
+    except OSError as exc:
+        if on_fault is not None:
+            on_fault(f"could not check whether {name} is a run's own session: {exc}")
+        return True
+    return any(mux.session_name_key(session_name(run_id)) == key for run_id in entries)
+
+
 def _legacy_registries() -> list[TerminalMultiplexer]:
     """Backends bound to registries this project's sessions may predate, or []
     (see :meth:`~.multiplexer.TerminalMultiplexer.legacy_registries`, which owns
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 6ddc4477..6bf3c3dd 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -2974,6 +2974,56 @@ def test_attach_names_a_pre_upgrade_control_session_it_cannot_see_into(
     )
 
 
+def test_attach_prints_no_command_for_a_name_a_run_of_this_project_has(
+    project, monkeypatch, capsys
+):
+    """#915: with a run dir for the id `ctl-<the old digest>`, the listed name may
+    be that run's own agent session, so attach names it without labelling it
+    only a control session to attach into: no command, and the clause says why.
+    Ablate the `superseded_ctl_may_be_run` branch in
+    `_note_superseded_ctl_for_attach` and this fails."""
+    from bmad_loop.tui import launch
+
+    _make_run_with_decision(project, run_id="20260101-000000-aaaa")
+    runs.run_dir_for(project.project, _DIGEST_CTL[len(runs.session_name("")) :]).mkdir(parents=True)
+    monkeypatch.setattr(launch, "attach_plan", lambda proj, rid, **_kw: (None, 0))
+    monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OwnRegistryMux())
+    monkeypatch.setattr(runs, "superseded_ctl_sessions", lambda _p, _m=None, **_kw: [_DIGEST_CTL])
+    monkeypatch.delenv("TMUX", raising=False)
+
+    assert cli.main(["attach", "--project", str(project.project), "20260101-000000-aaaa"]) == 1
+    err = capsys.readouterr().err
+    assert f"pre-upgrade control session {_DIGEST_CTL} is still running" in err
+    assert "a run of this project with that id may own it" in err
+    assert "psmux attach" not in err and "PSMUX_DATA_DIR" not in err
+
+
+def test_attach_says_when_it_could_not_check_the_runs_dir_for_that_id(project, monkeypatch, capsys):
+    """#915: a runs dir that could not be read to rule out a run owning the
+    pre-upgrade control-session name withholds the attach command, and the
+    failed check is said on stderr rather than left as the ambiguity clause
+    alone. Ablate the `on_fault` handed to `superseded_ctl_may_be_run` in
+    `_note_superseded_ctl_for_attach` and this fails."""
+    from bmad_loop.tui import launch
+
+    def _unreadable(_project, _name, _mux, *, on_fault=None):
+        assert on_fault is not None
+        on_fault("runs dir unreadable")
+        return True
+
+    _make_run_with_decision(project, run_id="20260101-000000-aaaa")
+    monkeypatch.setattr(launch, "attach_plan", lambda proj, rid, **_kw: (None, 0))
+    monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OwnRegistryMux())
+    monkeypatch.setattr(runs, "superseded_ctl_sessions", lambda _p, _m=None, **_kw: [_DIGEST_CTL])
+    monkeypatch.setattr(runs, "superseded_ctl_may_be_run", _unreadable)
+    monkeypatch.delenv("TMUX", raising=False)
+
+    assert cli.main(["attach", "--project", str(project.project), "20260101-000000-aaaa"]) == 1
+    err = capsys.readouterr().err
+    assert "note: runs dir unreadable" in err
+    assert "psmux attach" not in err and "PSMUX_DATA_DIR" not in err
+
+
 def test_attach_inside_a_client_names_switch_client_not_a_nested_attach(
     project, monkeypatch, capsys
 ):
@@ -19800,6 +19850,68 @@ def test_cleanup_prints_the_kill_command_for_a_pre_upgrade_control_session(
     assert captured.err == ""
 
 
+def test_cleanup_prints_no_kill_command_for_a_name_a_run_of_this_project_has(
+    project, capsys, monkeypatch
+):
+    """#915: a run whose id is `ctl-<the old digest>` owns `bmad-loop-<id>`, the
+    very name the old release minted for the control session, and that run may
+    be live. It is still named, but with no command: absent from
+    `legacy_kill_commands`, and the text says why. Ablate the
+    `superseded_ctl_may_be_run` branch in `_superseded_ctl_kill_commands` and
+    this fails."""
+    from bmad_loop.tui import launch
+
+    runs.run_dir_for(project.project, _DIGEST_CTL[len(runs.session_name("")) :]).mkdir(parents=True)
+    monkeypatch.setattr(runs, "prune_sessions", lambda _p, dry_run=False: ([], [], set()))
+    monkeypatch.setattr(
+        runs, "legacy_registry_leftovers", lambda _p, announced=(): ({_OWN_REG: [_DIGEST_CTL]}, [])
+    )
+    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
+    monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OwnRegistryMux())
+    monkeypatch.setattr(runs, "superseded_ctl_name", lambda _p, _r=None: _DIGEST_CTL)
+
+    assert cli.main(["cleanup", "--project", str(project.project)]) == 0
+    err = capsys.readouterr().err
+    assert f"pre-upgrade control session {_DIGEST_CTL}" in err
+    assert "a run of this project with that id may own it" in err
+    assert "kill-session" not in err and "end it with" not in err
+
+    assert cli.main(["cleanup", "--json", "--project", str(project.project)]) == 0
+    captured = capsys.readouterr()
+    doc = json.loads(captured.out)
+    assert doc["sessions"]["legacy_kill_commands"] == {}
+    assert doc["sessions"]["legacy_leftovers"] == [_DIGEST_CTL]
+    assert captured.err == ""
+
+
+def test_cleanup_reports_a_runs_dir_it_could_not_check_for_that_id(project, capsys, monkeypatch):
+    """#915: when the runs dir cannot be read to rule out a run owning the
+    pre-upgrade control-session name, the command is withheld and the failed
+    check is said, in `legacy_unverified` under this registry's label, never
+    folded into a bare omission. Ablate the `on_fault` handed to
+    `superseded_ctl_may_be_run` in `_superseded_ctl_kill_commands` and this fails."""
+    from bmad_loop.tui import launch
+
+    def _unreadable(_project, _name, _mux, *, on_fault=None):
+        assert on_fault is not None
+        on_fault("runs dir unreadable")
+        return True
+
+    monkeypatch.setattr(runs, "prune_sessions", lambda _p, dry_run=False: ([], [], set()))
+    monkeypatch.setattr(
+        runs, "legacy_registry_leftovers", lambda _p, announced=(): ({_OWN_REG: [_DIGEST_CTL]}, [])
+    )
+    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
+    monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OwnRegistryMux())
+    monkeypatch.setattr(runs, "superseded_ctl_name", lambda _p, _r=None: _DIGEST_CTL)
+    monkeypatch.setattr(runs, "superseded_ctl_may_be_run", _unreadable)
+
+    assert cli.main(["cleanup", "--json", "--project", str(project.project)]) == 0
+    doc = json.loads(capsys.readouterr().out)
+    assert doc["sessions"]["legacy_kill_commands"] == {}
+    assert doc["sessions"]["legacy_unverified"] == [f"{_OWN_REG}: runs dir unreadable"]
+
+
 def test_cleanup_names_a_legacy_registry_that_could_not_be_asked(project, capsys, monkeypatch):
     """DW-469: a registry whose listing raised used to print exactly what an empty
     one prints — nothing. Text names it on stderr; --json carries it as
diff --git a/tests/test_runs.py b/tests/test_runs.py
index 0de615a8..fdb8b431 100644
--- a/tests/test_runs.py
+++ b/tests/test_runs.py
@@ -9191,6 +9191,58 @@ def boom():
     assert len(faults) == 1 and "no backend" in faults[0]
 
 
+def test_legacy_registry_leftovers_still_scans_our_own_registry_when_discovery_fails(
+    tmp_path, monkeypatch
+):
+    """#915: a legacy discovery that raises used to return early, so the scan of
+    the project's own registry for the pre-upgrade control session never ran.
+    Both results are kept: that session named, the discovery fault reported.
+    Ablate the discovery's own `try` back to the early return and this fails."""
+    own = str(runs.mux_registry_root(tmp_path))
+    old = runs.superseded_ctl_name(tmp_path)
+
+    def boom():
+        raise MultiplexerError("legacy discovery failed")
+
+    monkeypatch.setattr(runs, "_legacy_registries", boom)
+    monkeypatch.setattr(runs, "get_multiplexer", lambda: _RegistryMux([old], {}, root=own))
+    assert runs.legacy_registry_leftovers(tmp_path) == (
+        {own: [old]},
+        ["no legacy registry could be checked: legacy discovery failed"],
+    )
+
+
+def test_superseded_ctl_may_be_run_when_a_run_has_the_id_its_name_spells(tmp_path, monkeypatch):
+    """#915: a run dir whose session the transport resolves to the listed name
+    means that name may be the run's own agent session; none means it cannot
+    be. A case variant counts where the transport folds (ablate the
+    `session_name_key` comparison back to the spelled id and the folding arm
+    fails), and not where it is exact. A runs dir that cannot be listed answers
+    True, the direction that withholds a command, and says so (ablate the
+    `on_fault` report or answer False there and this fails)."""
+    name = runs.superseded_ctl_name(tmp_path)
+    exact = _RegistryMux([], {})
+    folding = _RegistryMux([], {}, fold=True)
+    assert runs.superseded_ctl_may_be_run(tmp_path, name, exact) is False
+    run_id = name[len(runs.session_name("")) :]
+    runs.run_dir_for(tmp_path, run_id.upper()).mkdir(parents=True)
+    assert runs.superseded_ctl_may_be_run(tmp_path, name, folding) is True
+    assert runs.superseded_ctl_may_be_run(tmp_path, name, exact) is False
+    # The exact spelling, in a project of its own: on a case-folding store a
+    # second mkdir here would reuse the upper-case dir.
+    spelled = tmp_path / "spelled"
+    runs.run_dir_for(spelled, run_id).mkdir(parents=True)
+    assert runs.superseded_ctl_may_be_run(spelled, name, exact) is True
+
+    def _denied(self):
+        raise PermissionError("access denied")
+
+    monkeypatch.setattr(Path, "iterdir", _denied)
+    faults: list[str] = []
+    assert runs.superseded_ctl_may_be_run(tmp_path, name, exact, on_fault=faults.append) is True
+    assert len(faults) == 1 and name in faults[0] and "access denied" in faults[0]
+
+
 def test_legacy_registry_leftovers_is_empty_with_no_legacy_registry(tmp_path, monkeypatch):
     monkeypatch.setattr(runs, "_legacy_registries", lambda: [])
     assert _healthy_leftovers(tmp_path) == {}

From 25443793636213b1548a2d0e4e768bda20d53e60 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Davor=20Raci=C4=87?= <davor.racic@gmail.com>
Date: Wed, 14 Oct 2026 13:30:13 +0200
Subject: [PATCH 07/11] fix(cleanup): withhold the command for a name whose
 session carries a run's project tag

In an honoured registry shared with other projects, a neighbour's run with
the old control-session digest as its id leaves no run dir in this project,
but its agent session carries a session-level project tag, which no control
session ever did. Treat such a session as a run's and withhold its kill or
attach command; a tag listing that faults withholds it too and is reported.
---
 CHANGELOG.md                 |  7 ++++---
 docs/multiplexer-backends.md |  5 +++--
 docs/reference/cli.md        |  2 +-
 src/bmad_loop/cli.py         | 10 +++++-----
 src/bmad_loop/documents.py   | 11 ++++++-----
 src/bmad_loop/runs.py        | 30 +++++++++++++++++++++++-------
 tests/test_cli.py            |  7 +++++--
 tests/test_runs.py           | 25 +++++++++++++++++++++++++
 8 files changed, 72 insertions(+), 25 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c63074d0..00eb34ad 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -97,9 +97,10 @@ breaking changes may land in a minor release.
   psmux registry: `cleanup` names it on stderr and in `sessions.legacy_leftovers` with the
   command that ends it (`sessions.legacy_kill_commands`), and `attach` names it when it finds
   nothing to attach (#733).
-- Print no kill or attach command for a pre-upgrade control-session name that a run of this
-  project has as its id (it may be that run's own session), and still check the project's own
-  registry when legacy-registry discovery fails (#915).
+- Print no kill or attach command for a pre-upgrade control-session name that may be a run's
+  own session (a run of this project has that id, or the session carries a run's project tag,
+  as a neighbour's run can in a shared registry), and still check the project's own registry
+  when legacy-registry discovery fails (#915).
 - Fire the TUI's stale state-root note on psmux too: the psmux backend now answers which
   value a new pane inherits through psmux 3.4.0's named `show-environment` (#660).
 - Fix the OpenCode V2 SSE-reconnect end-to-end test failing on slow runners (Windows): the
diff --git a/docs/multiplexer-backends.md b/docs/multiplexer-backends.md
index 7e72c224..6b4bf30e 100644
--- a/docs/multiplexer-backends.md
+++ b/docs/multiplexer-backends.md
@@ -143,8 +143,9 @@ the exit banner (see `capture-pane` below). Then run
 (matched by that exact name, since a run id `ctl-<16 hex>` gives an agent session the same
 shape) on stderr and in `sessions.legacy_leftovers`, with that command ready to paste
 (`sessions.legacy_kill_commands` in `--json`). `attach` names it when it finds nothing to
-attach, with `switch-client` instead of `attach` when run inside a psmux pane. A name a run
-of this project has as its id may be that run's own session, so it is named with no command.
+attach, with `switch-client` instead of `attach` when run inside a psmux pane. A name that
+may be a run's own session (a run of this project has that id, or the session carries a run's
+project tag, as a neighbour's run can in a shared registry) is named with no command.
 
 **If the state root cannot be derived** (for example, `BMAD_LOOP_STATE_DIR` is a relative
 path), bmad-loop says so and leaves whatever `PSMUX_DATA_DIR` was in force. `cleanup` then
diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index e7b2e958..d77a4f19 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -546,7 +546,7 @@ The `--dry-run` plan and the outcome share this shape.
 | `sessions`    | object | agent sessions (below)         |
 | `ctl_windows` | object | control windows (below)        |
 
-`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_kill_commands` (a pre-upgrade control session in this project's registry mapped to the command that ends it, `null` when the backend is not psmux; a session a run of this project may own is left out), `legacy_unverified`, and `scan_error` (present only when the scan failed).
+`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_kill_commands` (a pre-upgrade control session in this project's registry mapped to the command that ends it, `null` when the backend is not psmux; a session a run may own is left out), `legacy_unverified`, and `scan_error` (present only when the scan failed).
 
 `ctl_windows`: `removed` (verified gone, or would close under `--dry-run`), `survived`, `unverifiable` (kill outcome could not be checked), `undetermined` (kept because the window's state could not be read), `scan_error` (str or null; when set, the other lists mean "no answer").
 
diff --git a/src/bmad_loop/cli.py b/src/bmad_loop/cli.py
index a814e191..c778dfb2 100644
--- a/src/bmad_loop/cli.py
+++ b/src/bmad_loop/cli.py
@@ -6452,7 +6452,7 @@ def _note_superseded_ctl_for_attach(project: Path) -> None:
     not passed off as "no such session" after "nothing to attach".
 
     A paste-ready command only on psmux (``_is_psmux``); another backend's
-    session is named without one, and so is a name a run of this project may
+    session is named without one, and so is a name a run may
     own (``runs.superseded_ctl_may_be_run``, #915)."""
     from .adapters.multiplexer import MultiplexerError, get_multiplexer
 
@@ -6755,11 +6755,11 @@ def _superseded_ctl_kill_commands(
     (:func:`_is_psmux`): the session is named, and no command is advertised
     that could not run there.
 
-    ``ambiguous`` holds each such name a run of this project may own
+    ``ambiguous`` holds each such name a run may own
     (``runs.superseded_ctl_may_be_run``, #915): it gets no command at all, so
     it is left out of the dict (and of ``--json`` ``legacy_kill_commands``)
-    while ``legacy_leftovers`` still names it. A runs dir that could not be
-    read for that check goes to ``on_fault``, labelled with the registry."""
+    while ``legacy_leftovers`` still names it. A check that could not be
+    made goes to ``on_fault``, labelled with the registry."""
     if not leftovers:
         return {}, []
     from .adapters.multiplexer import MultiplexerError, get_multiplexer
@@ -6792,7 +6792,7 @@ def _superseded_ctl_kill_commands(
 
 #: Why a pre-upgrade control-session name gets no command (#915), said the
 #: same way by cleanup and attach.
-_MAY_BE_RUN = "a run of this project with that id may own it"
+_MAY_BE_RUN = "a run with that id may own it"
 
 
 def _warn_superseded_ctl(kill_commands: dict[str, str | None], ambiguous: list[str]) -> None:
diff --git a/src/bmad_loop/documents.py b/src/bmad_loop/documents.py
index 8a14d21a..caa862d2 100644
--- a/src/bmad_loop/documents.py
+++ b/src/bmad_loop/documents.py
@@ -464,11 +464,12 @@ def cleanup_document(
     the paste-ready command that ends it, or to ``null`` when the backend is
     not psmux and no command can be spelled for it. No bmad-loop command
     addresses such a session, so this is the only way out; run it once every
-    window in it has parked. A session a run of this project may own (a run dir
-    exists for the id its name spells, #915) gets no command and is left out,
-    though `legacy_leftovers` still names it; a runs dir that could not be read
-    for that check withholds it too, and lands in `legacy_unverified`. Additive, no schema bump; the text
-    mode prints each on stderr.
+    window in it has parked. A session a run may own (a run dir exists for the
+    id its name spells, or the session carries a session-level project tag,
+    #915) gets no command and is left out, though `legacy_leftovers` still
+    names it; a check that could not be made withholds it too, and lands in
+    `legacy_unverified`. Additive, no schema bump; the text mode prints each on
+    stderr.
 
     `sessions.scan_error` is present only when the session listing could not
     see this project's sessions (#864): the backend is unavailable while a run
diff --git a/src/bmad_loop/runs.py b/src/bmad_loop/runs.py
index f2ab9e65..9528bd0a 100644
--- a/src/bmad_loop/runs.py
+++ b/src/bmad_loop/runs.py
@@ -2624,7 +2624,7 @@ def superseded_ctl_may_be_run(
     on_fault: Callable[[str], None] | None = None,
 ) -> bool:
     """True when the pre-upgrade control-session name ``name`` (as listed) may
-    instead be the agent session of a run of ``project`` (#915).
+    instead be a run's agent session (#915).
 
     A run id equal to the old digest, ``ctl-<16 hex>`` (one supplied by hand
     or persisted by an older release), owns ``bmad-loop-<id>`` — the very name
@@ -2635,18 +2635,34 @@ def superseded_ctl_may_be_run(
     variant counts where the transport folds) is enough to withhold a kill or
     attach command for it.
 
-    A runs dir that cannot be listed answers True, the direction that withholds
-    a command, and the fault goes to ``on_fault``."""
+    So is a session-level :data:`PROJECT_OPTION` tag, whatever its value: an
+    agent session carries one from creation, and no release ever set one on a
+    control session (its windows carry the tag). In an honoured root shared
+    with other projects, that is how a neighbour's run with that id shows up
+    while this project has no run dir for it.
+
+    A runs dir or a tag listing that cannot be read answers True, the direction
+    that withholds a command, and the fault goes to ``on_fault``."""
     key = mux.session_name_key(name)
+
+    def _fault(what: str, exc: Exception) -> bool:
+        if on_fault is not None:
+            on_fault(f"could not check whether {name} is a run's own session ({what}): {exc}")
+        return True
+
     try:
         entries = [entry.name for entry in (project / RUNS_DIR).iterdir()]
     except (FileNotFoundError, NotADirectoryError):
-        return False
+        entries = []
     except OSError as exc:
-        if on_fault is not None:
-            on_fault(f"could not check whether {name} is a run's own session: {exc}")
+        return _fault("runs dir", exc)
+    if any(mux.session_name_key(session_name(run_id)) == key for run_id in entries):
         return True
-    return any(mux.session_name_key(session_name(run_id)) == key for run_id in entries)
+    try:
+        tags = mux.session_options(PROJECT_OPTION)
+    except MultiplexerError as exc:
+        return _fault("session tags", exc)
+    return any(value and mux.session_name_key(s) == key for s, value in tags.items())
 
 
 def _legacy_registries() -> list[TerminalMultiplexer]:
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 6bf3c3dd..c2577dcc 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -2926,6 +2926,9 @@ def registry_root(self):
     def session_name_key(self, name):
         return name
 
+    def session_options(self, _option):
+        return {}
+
     def attach_target_argv(self, target):
         return ["othermux", "attach", "-t", target]
 
@@ -2994,7 +2997,7 @@ def test_attach_prints_no_command_for_a_name_a_run_of_this_project_has(
     assert cli.main(["attach", "--project", str(project.project), "20260101-000000-aaaa"]) == 1
     err = capsys.readouterr().err
     assert f"pre-upgrade control session {_DIGEST_CTL} is still running" in err
-    assert "a run of this project with that id may own it" in err
+    assert "a run with that id may own it" in err
     assert "psmux attach" not in err and "PSMUX_DATA_DIR" not in err
 
 
@@ -19873,7 +19876,7 @@ def test_cleanup_prints_no_kill_command_for_a_name_a_run_of_this_project_has(
     assert cli.main(["cleanup", "--project", str(project.project)]) == 0
     err = capsys.readouterr().err
     assert f"pre-upgrade control session {_DIGEST_CTL}" in err
-    assert "a run of this project with that id may own it" in err
+    assert "a run with that id may own it" in err
     assert "kill-session" not in err and "end it with" not in err
 
     assert cli.main(["cleanup", "--json", "--project", str(project.project)]) == 0
diff --git a/tests/test_runs.py b/tests/test_runs.py
index fdb8b431..6035bc45 100644
--- a/tests/test_runs.py
+++ b/tests/test_runs.py
@@ -9243,6 +9243,31 @@ def _denied(self):
     assert len(faults) == 1 and name in faults[0] and "access denied" in faults[0]
 
 
+def test_superseded_ctl_may_be_run_when_the_session_carries_a_project_tag(tmp_path):
+    """#915: in a shared registry a neighbour's run with that id leaves no run
+    dir here, but its session carries a session-level project tag, which no
+    control session ever did (ablate the tag check and the neighbour arm
+    fails). An untagged session stays a control session; a tag listing that
+    faults withholds the command and says so."""
+    name = runs.superseded_ctl_name(tmp_path)
+    neighbour = _RegistryMux([name], {name: "0123456789abcdef"}, fold=True)
+    assert runs.superseded_ctl_may_be_run(tmp_path, name.upper(), neighbour) is True
+    assert runs.superseded_ctl_may_be_run(tmp_path, name, _RegistryMux([name], {name: ""})) is False
+
+    class _Faulting(_RegistryMux):
+        def session_options(self, _option):
+            raise MultiplexerError("server gone")
+
+    faults: list[str] = []
+    assert (
+        runs.superseded_ctl_may_be_run(
+            tmp_path, name, _Faulting([name], {}), on_fault=faults.append
+        )
+        is True
+    )
+    assert len(faults) == 1 and name in faults[0] and "server gone" in faults[0]
+
+
 def test_legacy_registry_leftovers_is_empty_with_no_legacy_registry(tmp_path, monkeypatch):
     monkeypatch.setattr(runs, "_legacy_registries", lambda: [])
     assert _healthy_leftovers(tmp_path) == {}

From 29f28a3dea3391e705a147ab95334d667f815bab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Davor=20Raci=C4=87?= <davor.racic@gmail.com>
Date: Wed, 14 Oct 2026 13:45:55 +0200
Subject: [PATCH 08/11] fix(attach): name a pre-upgrade control session when no
 run is left

Runs archived or cleaned while their windows stay parked in the
pre-upgrade control session left attach at its no-runs exit, which never
looked for that session. That exit now names it too, with wording that
assumes no selected run.
---
 CHANGELOG.md                 |  5 +++--
 docs/multiplexer-backends.md |  2 +-
 src/bmad_loop/cli.py         | 19 ++++++++++++-------
 tests/test_cli.py            | 17 +++++++++++++++++
 4 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 00eb34ad..41b9dd25 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -99,8 +99,9 @@ breaking changes may land in a minor release.
   nothing to attach (#733).
 - Print no kill or attach command for a pre-upgrade control-session name that may be a run's
   own session (a run of this project has that id, or the session carries a run's project tag,
-  as a neighbour's run can in a shared registry), and still check the project's own registry
-  when legacy-registry discovery fails (#915).
+  as a neighbour's run can in a shared registry), still check the project's own registry
+  when legacy-registry discovery fails, and have `attach` name the pre-upgrade control session
+  when it finds no run at all (#915).
 - Fire the TUI's stale state-root note on psmux too: the psmux backend now answers which
   value a new pane inherits through psmux 3.4.0's named `show-environment` (#660).
 - Fix the OpenCode V2 SSE-reconnect end-to-end test failing on slow runners (Windows): the
diff --git a/docs/multiplexer-backends.md b/docs/multiplexer-backends.md
index 6b4bf30e..1a1d111e 100644
--- a/docs/multiplexer-backends.md
+++ b/docs/multiplexer-backends.md
@@ -142,7 +142,7 @@ the exit banner (see `capture-pane` below). Then run
 `cleanup` names the one an earlier release started for this project in its registry
 (matched by that exact name, since a run id `ctl-<16 hex>` gives an agent session the same
 shape) on stderr and in `sessions.legacy_leftovers`, with that command ready to paste
-(`sessions.legacy_kill_commands` in `--json`). `attach` names it when it finds nothing to
+(`sessions.legacy_kill_commands` in `--json`). `attach` names it when it finds no run or nothing to
 attach, with `switch-client` instead of `attach` when run inside a psmux pane. A name that
 may be a run's own session (a run of this project has that id, or the session carries a run's
 project tag, as a neighbour's run can in a shared registry) is named with no command.
diff --git a/src/bmad_loop/cli.py b/src/bmad_loop/cli.py
index c778dfb2..12b40922 100644
--- a/src/bmad_loop/cli.py
+++ b/src/bmad_loop/cli.py
@@ -6434,10 +6434,14 @@ def cmd_list(args: argparse.Namespace) -> int:
     return 0
 
 
-def _note_superseded_ctl_for_attach(project: Path) -> None:
-    """After "nothing to attach": name each pre-upgrade control session still
-    standing in this project's registry (#733), with the command that attaches
-    to it, because a run window parked there is one attach cannot see.
+def _note_superseded_ctl_for_attach(
+    project: Path, where: str = "this run's window may be there"
+) -> None:
+    """After "nothing to attach" (or "no runs found", whose runs may have been
+    archived while their windows stay parked, with a ``where`` that names no
+    run): name each pre-upgrade control session still standing in this
+    project's registry (#733), with the command that attaches to it, because a
+    run window parked there is one attach cannot see.
 
     Named, not adopted. attach, stop and the parked-window sweep address
     ``runs.ctl_session_for`` only (see ``runs.is_ctl_session_name``); finding
@@ -6482,13 +6486,13 @@ def _fault(msg: str) -> None:
                 file=sys.stderr,
             )
             continue
-        where = "this run's window may be there"
+        how = where
         if psmux:
             verb = mux.attach_target_argv(f"={name}")[1]
-            where += ": " + _psmux_command(mux.registry_root(), f"{verb} -t '={name}'")
+            how += ": " + _psmux_command(mux.registry_root(), f"{verb} -t '={name}'")
         print(
             f"note: pre-upgrade control session {name} is still running in this "
-            f"project's registry, and attach does not look inside it; {where}",
+            f"project's registry, and attach does not look inside it; {how}",
             file=sys.stderr,
         )
 
@@ -6507,6 +6511,7 @@ def cmd_attach(args: argparse.Namespace) -> int:
         run_dir = _latest_run_dir(project)
     if run_dir is None:
         print("no runs found", file=sys.stderr)
+        _note_superseded_ctl_for_attach(project, "a run's window may be there")
         return 1
     # A ctl listing that could not be read is said, then the attach carries on
     # to the agent session rather than failing on a window it could not check.
diff --git a/tests/test_cli.py b/tests/test_cli.py
index c2577dcc..e8e5e9f7 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -2953,6 +2953,23 @@ def test_attach_names_a_pre_upgrade_control_session_without_a_command_off_psmux(
     assert "psmux" not in err and "PSMUX_DATA_DIR" not in err
 
 
+def test_attach_with_no_runs_left_still_names_a_pre_upgrade_control_session(
+    project, monkeypatch, capsys
+):
+    """#915: runs archived or cleaned while their windows stay parked in the
+    pre-upgrade control session leave attach with no run dir, and that exit
+    still names the session, with wording that assumes no selected run.
+    Ablate the call on the no-runs exit and this fails."""
+    monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OtherRegistryMux())
+    monkeypatch.setattr(runs, "superseded_ctl_sessions", lambda _p, _m=None, **_kw: [_DIGEST_CTL])
+
+    assert cli.main(["attach", "--project", str(project.project)]) == 1
+    err = capsys.readouterr().err
+    assert "no runs found" in err
+    assert f"pre-upgrade control session {_DIGEST_CTL} is still running" in err
+    assert "a run's window may be there\n" in err and "this run's" not in err
+
+
 def test_attach_names_a_pre_upgrade_control_session_it_cannot_see_into(
     project, monkeypatch, capsys
 ):

From 45bac91c2ccf0765725887a6c5ec9fff732a45c3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Davor=20Raci=C4=87?= <davor.racic@gmail.com>
Date: Wed, 14 Oct 2026 14:01:35 +0200
Subject: [PATCH 09/11] fix(attach): name a pre-upgrade control session after
 an unresolved run ref

A run id given explicitly whose run dir was archived or cleaned while its
window stays parked in the pre-upgrade control session hit attach's
RunRefError exit first, which never looked for that session.
---
 src/bmad_loop/cli.py | 3 +++
 tests/test_cli.py    | 7 +++++++
 2 files changed, 10 insertions(+)

diff --git a/src/bmad_loop/cli.py b/src/bmad_loop/cli.py
index 12b40922..0089040b 100644
--- a/src/bmad_loop/cli.py
+++ b/src/bmad_loop/cli.py
@@ -6505,7 +6505,10 @@ def cmd_attach(args: argparse.Namespace) -> int:
         try:
             run_dir = runs.resolve_run_dir(project, args.run_id)
         except runs.RunRefError as e:
+            # The run dir may be archived or cleaned while its window stays
+            # parked in a pre-upgrade control session (#915).
             print(str(e), file=sys.stderr)
+            _note_superseded_ctl_for_attach(project, "a run's window may be there")
             return 1
     else:
         run_dir = _latest_run_dir(project)
diff --git a/tests/test_cli.py b/tests/test_cli.py
index e8e5e9f7..a6307e46 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -2969,6 +2969,13 @@ def test_attach_with_no_runs_left_still_names_a_pre_upgrade_control_session(
     assert f"pre-upgrade control session {_DIGEST_CTL} is still running" in err
     assert "a run's window may be there\n" in err and "this run's" not in err
 
+    # The same for a run id given explicitly whose run dir is gone (ablate the
+    # call on the RunRefError exit and this half fails).
+    assert cli.main(["attach", "--project", str(project.project), "20260101-000000-gone"]) == 1
+    err = capsys.readouterr().err
+    assert f"pre-upgrade control session {_DIGEST_CTL} is still running" in err
+    assert "a run's window may be there\n" in err
+
 
 def test_attach_names_a_pre_upgrade_control_session_it_cannot_see_into(
     project, monkeypatch, capsys

From db43e238bc89211b70c4ee31999b99cb4cd75232 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Davor=20Raci=C4=87?= <davor.racic@gmail.com>
Date: Wed, 14 Oct 2026 16:36:50 +0200
Subject: [PATCH 10/11] fix(cleanup): keep command-check faults out of
 legacy_unverified

legacy_unverified means a whole legacy registry could not be asked, and
the text mode renders every entry as such. A runs-dir or session-tag check
that faulted while withholding a pre-upgrade control session's command
happened after the registry was listed, so it now goes to its own additive
field, sessions.legacy_command_unverified, and to a note on stderr.
---
 docs/reference/cli.md      |  2 +-
 src/bmad_loop/cli.py       | 18 +++++++++++++-----
 src/bmad_loop/documents.py | 13 ++++++++++---
 tests/test_cli.py          | 19 +++++++++++++++----
 4 files changed, 39 insertions(+), 13 deletions(-)

diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index d77a4f19..ed6675b1 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -546,7 +546,7 @@ The `--dry-run` plan and the outcome share this shape.
 | `sessions`    | object | agent sessions (below)         |
 | `ctl_windows` | object | control windows (below)        |
 
-`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_kill_commands` (a pre-upgrade control session in this project's registry mapped to the command that ends it, `null` when the backend is not psmux; a session a run may own is left out), `legacy_unverified`, and `scan_error` (present only when the scan failed).
+`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_kill_commands` (a pre-upgrade control session in this project's registry mapped to the command that ends it, `null` when the backend is not psmux; a session a run may own is left out), `legacy_unverified`, `legacy_command_unverified` (a check that withheld such a command could not be made; the registry itself was listed), and `scan_error` (present only when the scan failed).
 
 `ctl_windows`: `removed` (verified gone, or would close under `--dry-run`), `survived`, `unverifiable` (kill outcome could not be checked), `undetermined` (kept because the window's state could not be read), `scan_error` (str or null; when set, the other lists mean "no answer").
 
diff --git a/src/bmad_loop/cli.py b/src/bmad_loop/cli.py
index 0089040b..00a88056 100644
--- a/src/bmad_loop/cli.py
+++ b/src/bmad_loop/cli.py
@@ -6767,7 +6767,8 @@ def _superseded_ctl_kill_commands(
     (``runs.superseded_ctl_may_be_run``, #915): it gets no command at all, so
     it is left out of the dict (and of ``--json`` ``legacy_kill_commands``)
     while ``legacy_leftovers`` still names it. A check that could not be
-    made goes to ``on_fault``, labelled with the registry."""
+    made goes to ``on_fault``, labelled with the registry (``cleanup`` keeps
+    it apart from ``legacy_unverified``: the registry itself was listed)."""
     if not leftovers:
         return {}, []
     from .adapters.multiplexer import MultiplexerError, get_multiplexer
@@ -6803,7 +6804,11 @@ def _superseded_ctl_kill_commands(
 _MAY_BE_RUN = "a run with that id may own it"
 
 
-def _warn_superseded_ctl(kill_commands: dict[str, str | None], ambiguous: list[str]) -> None:
+def _warn_superseded_ctl(
+    kill_commands: dict[str, str | None], ambiguous: list[str], faults: list[str]
+) -> None:
+    for fault in faults:
+        print(f"note: {fault}", file=sys.stderr)
     for name in ambiguous:
         print(
             f"pre-upgrade control session {name} is still running in this project's "
@@ -6905,8 +6910,10 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
     leftovers, unverified = runs.legacy_registry_leftovers(
         project, announced=killed if args.dry_run else ()
     )
+    # Not `unverified`: the registry was listed, only a command was withheld.
+    ctl_command_faults: list[str] = []
     kill_commands, ambiguous_ctl = _superseded_ctl_kill_commands(
-        project, leftovers, unverified.append
+        project, leftovers, ctl_command_faults.append
     )
     # The listing behind prune_sessions reads an unavailable backend as no
     # sessions; this names the cases where that is not a clean answer (#864).
@@ -6985,6 +6992,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
                 legacy_unverified=unverified,
                 legacy_kill_commands=kill_commands,
                 sessions_scan_error=sessions_scan_error,
+                legacy_command_unverified=ctl_command_faults,
             )
         )
         return 0
@@ -6999,7 +7007,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
         if live:
             print(f"leaving {len(live)} live session(s) untouched")
         _warn_legacy_leftovers(project, leftovers, unverified)
-        _warn_superseded_ctl(kill_commands, ambiguous_ctl)
+        _warn_superseded_ctl(kill_commands, ambiguous_ctl, ctl_command_faults)
         return 0
     # The count now excludes non-removals, so on stdout alone a smaller number is
     # indistinguishable from a quieter sweep — and `cleanup > log` keeps only
@@ -7018,7 +7026,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
         # moving between the two surfaces is reading the same thing.
         print(f"ctl window(s) still open after the kill: {', '.join(survived)}", file=sys.stderr)
     _warn_legacy_leftovers(project, leftovers, unverified)
-    _warn_superseded_ctl(kill_commands, ambiguous_ctl)
+    _warn_superseded_ctl(kill_commands, ambiguous_ctl, ctl_command_faults)
     if unverifiable:
         # Not "killed but unverifiable": kill_window is a silent no-op on a
         # transport failure, so whether the kill even reached the server is part
diff --git a/src/bmad_loop/documents.py b/src/bmad_loop/documents.py
index caa862d2..0f8c4c42 100644
--- a/src/bmad_loop/documents.py
+++ b/src/bmad_loop/documents.py
@@ -399,6 +399,7 @@ def cleanup_document(
     legacy_unverified: list[str] | None = None,
     legacy_kill_commands: dict[str, str | None] | None = None,
     sessions_scan_error: str | None = None,
+    legacy_command_unverified: list[str] | None = None,
 ) -> dict[str, object]:
     """The `cleanup --json` document: the multiplexer artifacts this invocation
     removed, or — under ``--dry-run`` — would remove.
@@ -467,9 +468,14 @@ def cleanup_document(
     window in it has parked. A session a run may own (a run dir exists for the
     id its name spells, or the session carries a session-level project tag,
     #915) gets no command and is left out, though `legacy_leftovers` still
-    names it; a check that could not be made withholds it too, and lands in
-    `legacy_unverified`. Additive, no schema bump; the text mode prints each on
-    stderr.
+    names it; a check that could not be made withholds it too. Additive, no
+    schema bump; the text mode prints each on stderr.
+
+    `sessions.legacy_command_unverified` is one line per such check that could
+    not be made (a runs dir or a session-tag listing that faulted, #915). The
+    registry itself was listed, so this is not `legacy_unverified`: the session
+    is in `legacy_leftovers`, only its command was withheld. Additive, no schema
+    bump; the text mode prints each line on stderr.
 
     `sessions.scan_error` is present only when the session listing could not
     see this project's sessions (#864): the backend is unavailable while a run
@@ -492,6 +498,7 @@ def cleanup_document(
         "legacy_leftovers": list(legacy_leftovers or []),
         "legacy_unverified": list(legacy_unverified or []),
         "legacy_kill_commands": dict(legacy_kill_commands or {}),
+        "legacy_command_unverified": list(legacy_command_unverified or []),
     }
     if sessions_scan_error is not None:
         sessions["scan_error"] = sessions_scan_error
diff --git a/tests/test_cli.py b/tests/test_cli.py
index a6307e46..9e08db12 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -7323,6 +7323,7 @@ def test_cleanup_json_dry_run_plans_without_pruning(tmp_path, monkeypatch, capsy
         "legacy_leftovers": [],
         "legacy_kill_commands": {},
         "legacy_unverified": [],
+        "legacy_command_unverified": [],
     }
     assert doc["ctl_windows"] == {
         "removed": ["sweep-fin-1"],
@@ -7382,6 +7383,7 @@ def test_cleanup_json_nothing_to_clean_up_is_a_valid_empty_document(tmp_path, mo
         "legacy_leftovers": [],
         "legacy_kill_commands": {},
         "legacy_unverified": [],
+        "legacy_command_unverified": [],
     }
     assert doc["ctl_windows"] == {
         "removed": [],
@@ -19914,9 +19916,11 @@ def test_cleanup_prints_no_kill_command_for_a_name_a_run_of_this_project_has(
 def test_cleanup_reports_a_runs_dir_it_could_not_check_for_that_id(project, capsys, monkeypatch):
     """#915: when the runs dir cannot be read to rule out a run owning the
     pre-upgrade control-session name, the command is withheld and the failed
-    check is said, in `legacy_unverified` under this registry's label, never
-    folded into a bare omission. Ablate the `on_fault` handed to
-    `superseded_ctl_may_be_run` in `_superseded_ctl_kill_commands` and this fails."""
+    check is said, in `legacy_command_unverified` under this registry's label
+    (and on stderr in text mode), never folded into a bare omission, and never
+    into `legacy_unverified`, which means the registry itself was not listed.
+    Ablate the `on_fault` handed to `superseded_ctl_may_be_run` in
+    `_superseded_ctl_kill_commands` and this fails."""
     from bmad_loop.tui import launch
 
     def _unreadable(_project, _name, _mux, *, on_fault=None):
@@ -19936,7 +19940,13 @@ def _unreadable(_project, _name, _mux, *, on_fault=None):
     assert cli.main(["cleanup", "--json", "--project", str(project.project)]) == 0
     doc = json.loads(capsys.readouterr().out)
     assert doc["sessions"]["legacy_kill_commands"] == {}
-    assert doc["sessions"]["legacy_unverified"] == [f"{_OWN_REG}: runs dir unreadable"]
+    assert doc["sessions"]["legacy_command_unverified"] == [f"{_OWN_REG}: runs dir unreadable"]
+    assert doc["sessions"]["legacy_unverified"] == []
+
+    assert cli.main(["cleanup", "--project", str(project.project)]) == 0
+    err = capsys.readouterr().err
+    assert f"note: {_OWN_REG}: runs dir unreadable" in err
+    assert "not checked" not in err
 
 
 def test_cleanup_names_a_legacy_registry_that_could_not_be_asked(project, capsys, monkeypatch):
@@ -20615,6 +20625,7 @@ def test_cleanup_json_unavailable_backend_without_evidence_is_unchanged(
         "legacy_leftovers": [],
         "legacy_kill_commands": {},
         "legacy_unverified": [],
+        "legacy_command_unverified": [],
     }
     assert doc["ctl_windows"]["scan_error"] is None
 

From de7a988220628d595170bfa259ae741c8fac8b9e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Davor=20Raci=C4=87?= <davor.racic@gmail.com>
Date: Wed, 14 Oct 2026 17:03:45 +0200
Subject: [PATCH 11/11] fix(cleanup): keep own-registry scan faults out of
 legacy_unverified

The scan of the project's own registry for a pre-upgrade control session
is no legacy-registry scan, but its faults were appended to the list that
cleanup serializes as legacy_unverified and renders as "legacy registry not
checked". legacy_registry_leftovers now takes on_primary_fault; cleanup puts
those faults, with the command-check faults, in the renamed additive field
sessions.superseded_ctl_unverified, and the TUI gives them their own toast.

The docs also qualify the manual kill-session instruction: not for a name
that may be a run's own session.
---
 docs/multiplexer-backends.md |  7 ++---
 docs/reference/cli.md        |  2 +-
 src/bmad_loop/cli.py         | 12 ++++++---
 src/bmad_loop/documents.py   | 16 +++++++-----
 src/bmad_loop/runs.py        | 14 +++++++---
 src/bmad_loop/tui/app.py     | 15 ++++++++++-
 tests/test_cli.py            | 50 +++++++++++++++++++-----------------
 tests/test_runs.py           | 22 ++++++++++++++++
 tests/test_tui_app.py        |  6 ++---
 9 files changed, 98 insertions(+), 46 deletions(-)

diff --git a/docs/multiplexer-backends.md b/docs/multiplexer-backends.md
index 1a1d111e..22d4125a 100644
--- a/docs/multiplexer-backends.md
+++ b/docs/multiplexer-backends.md
@@ -136,8 +136,8 @@ named `bmad-loop-ctl-<16 hex>` is also a control session to bmad-loop, so `clean
 prunes it. Nothing launches into it, though, so the TUI's attach and stop keys and the
 parked-window sweep do not reach its windows. To end one, let its runs finish
 (`bmad-loop stop` reaches a live engine wherever it runs) and check that every window shows
-the exit banner (see `capture-pane` below). Then run
-`psmux kill-session -t bmad-loop-ctl-<16 hex>`.
+the exit banner (see `capture-pane` below). Then, unless the name may be a run's own session
+(below), run `psmux kill-session -t bmad-loop-ctl-<16 hex>`.
 
 `cleanup` names the one an earlier release started for this project in its registry
 (matched by that exact name, since a run id `ctl-<16 hex>` gives an agent session the same
@@ -145,7 +145,8 @@ shape) on stderr and in `sessions.legacy_leftovers`, with that command ready to
 (`sessions.legacy_kill_commands` in `--json`). `attach` names it when it finds no run or nothing to
 attach, with `switch-client` instead of `attach` when run inside a psmux pane. A name that
 may be a run's own session (a run of this project has that id, or the session carries a run's
-project tag, as a neighbour's run can in a shared registry) is named with no command.
+project tag, as a neighbour's run can in a shared registry) is named with no command; do not
+end it by hand until you know which it is.
 
 **If the state root cannot be derived** (for example, `BMAD_LOOP_STATE_DIR` is a relative
 path), bmad-loop says so and leaves whatever `PSMUX_DATA_DIR` was in force. `cleanup` then
diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index ed6675b1..a2ec3483 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -546,7 +546,7 @@ The `--dry-run` plan and the outcome share this shape.
 | `sessions`    | object | agent sessions (below)         |
 | `ctl_windows` | object | control windows (below)        |
 
-`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_kill_commands` (a pre-upgrade control session in this project's registry mapped to the command that ends it, `null` when the backend is not psmux; a session a run may own is left out), `legacy_unverified`, `legacy_command_unverified` (a check that withheld such a command could not be made; the registry itself was listed), and `scan_error` (present only when the scan failed).
+`sessions`: `removed` (run ids whose session kill was attempted), `live` (left alone), `unverifiable_pid` (subset of `removed` whose engine liveness could not be proven), `legacy_leftovers`, `legacy_kill_commands` (a pre-upgrade control session in this project's registry mapped to the command that ends it, `null` when the backend is not psmux; a session a run may own is left out), `legacy_unverified`, `superseded_ctl_unverified` (a check on this project's own registry for such a session, or one that withholds its command, could not be made), and `scan_error` (present only when the scan failed).
 
 `ctl_windows`: `removed` (verified gone, or would close under `--dry-run`), `survived`, `unverifiable` (kill outcome could not be checked), `undetermined` (kept because the window's state could not be read), `scan_error` (str or null; when set, the other lists mean "no answer").
 
diff --git a/src/bmad_loop/cli.py b/src/bmad_loop/cli.py
index 00a88056..d720a432 100644
--- a/src/bmad_loop/cli.py
+++ b/src/bmad_loop/cli.py
@@ -6907,11 +6907,15 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
     # this command printed, never a second sample of it. Never raises: a registry
     # that could not be asked lands in `unverified` (DW-469), never in an empty
     # `leftovers` that reads as "nothing left".
+    # Not `unverified`, which means a legacy registry could not be asked: these
+    # are checks on this project's own registry for a pre-upgrade control
+    # session (#915), its scan or a check that withheld its command.
+    ctl_command_faults: list[str] = []
     leftovers, unverified = runs.legacy_registry_leftovers(
-        project, announced=killed if args.dry_run else ()
+        project,
+        announced=killed if args.dry_run else (),
+        on_primary_fault=ctl_command_faults.append,
     )
-    # Not `unverified`: the registry was listed, only a command was withheld.
-    ctl_command_faults: list[str] = []
     kill_commands, ambiguous_ctl = _superseded_ctl_kill_commands(
         project, leftovers, ctl_command_faults.append
     )
@@ -6992,7 +6996,7 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
                 legacy_unverified=unverified,
                 legacy_kill_commands=kill_commands,
                 sessions_scan_error=sessions_scan_error,
-                legacy_command_unverified=ctl_command_faults,
+                superseded_ctl_unverified=ctl_command_faults,
             )
         )
         return 0
diff --git a/src/bmad_loop/documents.py b/src/bmad_loop/documents.py
index 0f8c4c42..fae267cb 100644
--- a/src/bmad_loop/documents.py
+++ b/src/bmad_loop/documents.py
@@ -399,7 +399,7 @@ def cleanup_document(
     legacy_unverified: list[str] | None = None,
     legacy_kill_commands: dict[str, str | None] | None = None,
     sessions_scan_error: str | None = None,
-    legacy_command_unverified: list[str] | None = None,
+    superseded_ctl_unverified: list[str] | None = None,
 ) -> dict[str, object]:
     """The `cleanup --json` document: the multiplexer artifacts this invocation
     removed, or — under ``--dry-run`` — would remove.
@@ -471,11 +471,13 @@ def cleanup_document(
     names it; a check that could not be made withholds it too. Additive, no
     schema bump; the text mode prints each on stderr.
 
-    `sessions.legacy_command_unverified` is one line per such check that could
-    not be made (a runs dir or a session-tag listing that faulted, #915). The
-    registry itself was listed, so this is not `legacy_unverified`: the session
-    is in `legacy_leftovers`, only its command was withheld. Additive, no schema
-    bump; the text mode prints each line on stderr.
+    `sessions.superseded_ctl_unverified` is one line per check on this
+    project's own registry for a pre-upgrade control session that could not be
+    made (#915): the scan for it (its name could not be derived, or the
+    registry could not be listed), or a check that withholds its command (a
+    runs dir or a session-tag listing that faulted). That registry is no legacy
+    one, so this is not `legacy_unverified`. Additive, no schema bump; the text
+    mode prints each line on stderr.
 
     `sessions.scan_error` is present only when the session listing could not
     see this project's sessions (#864): the backend is unavailable while a run
@@ -498,7 +500,7 @@ def cleanup_document(
         "legacy_leftovers": list(legacy_leftovers or []),
         "legacy_unverified": list(legacy_unverified or []),
         "legacy_kill_commands": dict(legacy_kill_commands or {}),
-        "legacy_command_unverified": list(legacy_command_unverified or []),
+        "superseded_ctl_unverified": list(superseded_ctl_unverified or []),
     }
     if sessions_scan_error is not None:
         sessions["scan_error"] = sessions_scan_error
diff --git a/src/bmad_loop/runs.py b/src/bmad_loop/runs.py
index 9528bd0a..08967303 100644
--- a/src/bmad_loop/runs.py
+++ b/src/bmad_loop/runs.py
@@ -2371,7 +2371,10 @@ def kill_displaced_session(project: Path, run_id: str) -> list[str]:
 
 
 def legacy_registry_leftovers(
-    project: Path, *, announced: Iterable[str] = ()
+    project: Path,
+    *,
+    announced: Iterable[str] = (),
+    on_primary_fault: Callable[[str], None] | None = None,
 ) -> tuple[dict[str, list[str]], list[str]]:
     """``(grouped, faults)``: session names a legacy registry **still holds** after
     :func:`prune_sessions` ran — the migration's honest remainder, for the cleanup
@@ -2533,14 +2536,17 @@ def legacy_registry_leftovers(
             label = legacy.registry_root() or DEFAULT_REGISTRY_LABEL
             grouped[label] = sorted(set(grouped.get(label, []) + here))
     # The project's own registry is no legacy one, but a control session an
-    # earlier release named there survives the rename too (#733).
+    # earlier release named there survives the rename too (#733). Its faults go
+    # to `on_primary_fault` when given (#915): that registry is no legacy one,
+    # so they are not "a legacy registry could not be asked".
     label = primary.registry_root() or DEFAULT_REGISTRY_LABEL
+    primary_fault = on_primary_fault or faults.append
     try:
         stale = superseded_ctl_sessions(
-            project, primary, on_fault=lambda msg: faults.append(f"{label}: {msg}")
+            project, primary, on_fault=lambda msg: primary_fault(f"{label}: {msg}")
         )
     except MultiplexerError as exc:
-        faults.append(f"{label}: could not be listed: {exc}")
+        primary_fault(f"{label}: could not be listed: {exc}")
         stale = []
     if stale:
         grouped[label] = sorted(set(grouped.get(label, []) + stale))
diff --git a/src/bmad_loop/tui/app.py b/src/bmad_loop/tui/app.py
index e0c230b7..c21d653d 100644
--- a/src/bmad_loop/tui/app.py
+++ b/src/bmad_loop/tui/app.py
@@ -2098,7 +2098,20 @@ def _cleanup_sessions_worker(self) -> None:
         # One toast per registry, naming it: there is more than one legacy
         # registry (psmux's default, and any root this process displaced), and
         # the operator's next action is to open the one holding these.
-        leftovers, unverified = runs.legacy_registry_leftovers(self.project)
+        ctl_faults: list[str] = []
+        leftovers, unverified = runs.legacy_registry_leftovers(
+            self.project, on_primary_fault=ctl_faults.append
+        )
+        # This project's own registry is no legacy one (#915): its scan for a
+        # pre-upgrade control session gets its own wording.
+        for line in ctl_faults:
+            self.call_from_thread(
+                self.notify,
+                f"could not check this project's registry for a pre-upgrade control "
+                f"session: {line}",
+                severity="warning",
+                markup=False,
+            )
         # DW-469: a registry that could not be asked is not one holding nothing.
         for line in unverified:
             self.call_from_thread(
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 9e08db12..b106ba43 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -7323,7 +7323,7 @@ def test_cleanup_json_dry_run_plans_without_pruning(tmp_path, monkeypatch, capsy
         "legacy_leftovers": [],
         "legacy_kill_commands": {},
         "legacy_unverified": [],
-        "legacy_command_unverified": [],
+        "superseded_ctl_unverified": [],
     }
     assert doc["ctl_windows"] == {
         "removed": ["sweep-fin-1"],
@@ -7383,7 +7383,7 @@ def test_cleanup_json_nothing_to_clean_up_is_a_valid_empty_document(tmp_path, mo
         "legacy_leftovers": [],
         "legacy_kill_commands": {},
         "legacy_unverified": [],
-        "legacy_command_unverified": [],
+        "superseded_ctl_unverified": [],
     }
     assert doc["ctl_windows"] == {
         "removed": [],
@@ -19594,7 +19594,7 @@ def test_cleanup_names_what_the_migration_left_behind(project, capsys, monkeypat
     monkeypatch.setattr(
         runs,
         "legacy_registry_leftovers",
-        lambda _p, announced=(): (
+        lambda _p, announced=(), **_kw: (
             {runs.DEFAULT_REGISTRY_LABEL: ["bmad-loop-ctl", "bmad-loop-old-1"]},
             [],
         ),
@@ -19617,7 +19617,7 @@ def test_cleanup_dry_run_previews_what_the_migration_would_leave_behind(
     monkeypatch.setattr(
         runs,
         "legacy_registry_leftovers",
-        lambda _p, announced=(): ({runs.DEFAULT_REGISTRY_LABEL: ["bmad-loop-old-1"]}, []),
+        lambda _p, announced=(), **_kw: ({runs.DEFAULT_REGISTRY_LABEL: ["bmad-loop-old-1"]}, []),
     )
     monkeypatch.setattr(launch, "prunable_ctl_windows", lambda _p: ([], []))
 
@@ -19644,13 +19644,13 @@ def test_cleanup_dry_run_hands_the_remainder_the_plan_it_printed(project, capsys
     seen: list[object] = []
     monkeypatch.setattr(runs, "prune_sessions", lambda _p, dry_run=False: (["old-1"], [], set()))
 
-    def _leftovers(_p, announced=()):
+    def _leftovers(_p, announced=(), **_kw):
         seen.append(sorted(announced))
         return {}, []
 
     monkeypatch.setattr(runs, "legacy_registry_leftovers", _leftovers)
-    monkeypatch.setattr(launch, "prunable_ctl_windows", lambda _p: ([], []))
-    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
+    monkeypatch.setattr(launch, "prunable_ctl_windows", lambda _p, **_kw: ([], []))
+    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p, **_kw: ([], [], [], []))
 
     assert cli.main(["cleanup", "--dry-run", "--project", str(project.project)]) == 0
     assert seen == [["old-1"]]
@@ -19669,7 +19669,7 @@ def test_cleanup_json_carries_the_remainder_and_leaves_stderr_empty(project, cap
     monkeypatch.setattr(
         runs,
         "legacy_registry_leftovers",
-        lambda _p, announced=(): ({runs.DEFAULT_REGISTRY_LABEL: ["bmad-loop-old-1"]}, []),
+        lambda _p, announced=(), **_kw: ({runs.DEFAULT_REGISTRY_LABEL: ["bmad-loop-old-1"]}, []),
     )
     monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
 
@@ -19702,7 +19702,7 @@ def test_cleanup_names_the_registry_each_leftover_is_actually_in(project, capsys
     monkeypatch.setattr(
         runs,
         "legacy_registry_leftovers",
-        lambda _p, announced=(): (
+        lambda _p, announced=(), **_kw: (
             {
                 runs.DEFAULT_REGISTRY_LABEL: ["bmad-loop-ctl"],
                 theirs: ["bmad-loop-old-1"],
@@ -19741,7 +19741,7 @@ def test_cleanup_says_a_derived_registry_of_another_project_path_is_not_a_remain
     monkeypatch.setattr(
         runs,
         "legacy_registry_leftovers",
-        lambda _p, announced=(): (
+        lambda _p, announced=(), **_kw: (
             {theirs: ["bmad-loop-bare-1", "bmad-loop-ctl"], plain: ["bmad-loop-old-1"]},
             [],
         ),
@@ -19776,7 +19776,7 @@ def test_cleanup_json_flattens_the_remainder_to_the_documented_list(project, cap
     monkeypatch.setattr(
         runs,
         "legacy_registry_leftovers",
-        lambda _p, announced=(): (
+        lambda _p, announced=(), **_kw: (
             {
                 runs.DEFAULT_REGISTRY_LABEL: ["bmad-loop-ctl"],
                 r"D:\theirs": ["bmad-loop-old-1"],
@@ -19797,8 +19797,8 @@ def test_cleanup_says_nothing_about_a_registry_with_no_remainder(project, capsys
     from bmad_loop.tui import launch
 
     monkeypatch.setattr(runs, "prune_sessions", lambda _p, dry_run=False: ([], [], set()))
-    monkeypatch.setattr(runs, "legacy_registry_leftovers", lambda _p, announced=(): ({}, []))
-    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
+    monkeypatch.setattr(runs, "legacy_registry_leftovers", lambda _p, announced=(), **_kw: ({}, []))
+    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p, **_kw: ([], [], [], []))
 
     assert cli.main(["cleanup", "--project", str(project.project)]) == 0
     err = capsys.readouterr().err
@@ -19817,7 +19817,7 @@ def test_cleanup_names_a_pre_upgrade_control_session_without_a_command_off_psmux
     monkeypatch.setattr(
         runs,
         "legacy_registry_leftovers",
-        lambda _p, announced=(): ({_OWN_REG: [_DIGEST_CTL]}, []),
+        lambda _p, announced=(), **_kw: ({_OWN_REG: [_DIGEST_CTL]}, []),
     )
     monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
     monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OtherRegistryMux())
@@ -19851,7 +19851,7 @@ def test_cleanup_prints_the_kill_command_for_a_pre_upgrade_control_session(
     monkeypatch.setattr(
         runs,
         "legacy_registry_leftovers",
-        lambda _p, announced=(): (
+        lambda _p, announced=(), **_kw: (
             {
                 # A run's agent session for run id `ctl-<16 hex>` shares the
                 # digest shape; it is not the old control session.
@@ -19893,9 +19893,11 @@ def test_cleanup_prints_no_kill_command_for_a_name_a_run_of_this_project_has(
     runs.run_dir_for(project.project, _DIGEST_CTL[len(runs.session_name("")) :]).mkdir(parents=True)
     monkeypatch.setattr(runs, "prune_sessions", lambda _p, dry_run=False: ([], [], set()))
     monkeypatch.setattr(
-        runs, "legacy_registry_leftovers", lambda _p, announced=(): ({_OWN_REG: [_DIGEST_CTL]}, [])
+        runs,
+        "legacy_registry_leftovers",
+        lambda _p, announced=(), **_kw: ({_OWN_REG: [_DIGEST_CTL]}, []),
     )
-    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
+    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p, **_kw: ([], [], [], []))
     monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OwnRegistryMux())
     monkeypatch.setattr(runs, "superseded_ctl_name", lambda _p, _r=None: _DIGEST_CTL)
 
@@ -19916,7 +19918,7 @@ def test_cleanup_prints_no_kill_command_for_a_name_a_run_of_this_project_has(
 def test_cleanup_reports_a_runs_dir_it_could_not_check_for_that_id(project, capsys, monkeypatch):
     """#915: when the runs dir cannot be read to rule out a run owning the
     pre-upgrade control-session name, the command is withheld and the failed
-    check is said, in `legacy_command_unverified` under this registry's label
+    check is said, in `superseded_ctl_unverified` under this registry's label
     (and on stderr in text mode), never folded into a bare omission, and never
     into `legacy_unverified`, which means the registry itself was not listed.
     Ablate the `on_fault` handed to `superseded_ctl_may_be_run` in
@@ -19930,9 +19932,11 @@ def _unreadable(_project, _name, _mux, *, on_fault=None):
 
     monkeypatch.setattr(runs, "prune_sessions", lambda _p, dry_run=False: ([], [], set()))
     monkeypatch.setattr(
-        runs, "legacy_registry_leftovers", lambda _p, announced=(): ({_OWN_REG: [_DIGEST_CTL]}, [])
+        runs,
+        "legacy_registry_leftovers",
+        lambda _p, announced=(), **_kw: ({_OWN_REG: [_DIGEST_CTL]}, []),
     )
-    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
+    monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p, **_kw: ([], [], [], []))
     monkeypatch.setattr(mux_mod, "get_multiplexer", lambda: _OwnRegistryMux())
     monkeypatch.setattr(runs, "superseded_ctl_name", lambda _p, _r=None: _DIGEST_CTL)
     monkeypatch.setattr(runs, "superseded_ctl_may_be_run", _unreadable)
@@ -19940,7 +19944,7 @@ def _unreadable(_project, _name, _mux, *, on_fault=None):
     assert cli.main(["cleanup", "--json", "--project", str(project.project)]) == 0
     doc = json.loads(capsys.readouterr().out)
     assert doc["sessions"]["legacy_kill_commands"] == {}
-    assert doc["sessions"]["legacy_command_unverified"] == [f"{_OWN_REG}: runs dir unreadable"]
+    assert doc["sessions"]["superseded_ctl_unverified"] == [f"{_OWN_REG}: runs dir unreadable"]
     assert doc["sessions"]["legacy_unverified"] == []
 
     assert cli.main(["cleanup", "--project", str(project.project)]) == 0
@@ -19960,7 +19964,7 @@ def test_cleanup_names_a_legacy_registry_that_could_not_be_asked(project, capsys
     monkeypatch.setattr(
         runs,
         "legacy_registry_leftovers",
-        lambda _p, announced=(): ({}, ["/reg/broken: could not be listed: no server"]),
+        lambda _p, announced=(), **_kw: ({}, ["/reg/broken: could not be listed: no server"]),
     )
     monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
 
@@ -20625,7 +20629,7 @@ def test_cleanup_json_unavailable_backend_without_evidence_is_unchanged(
         "legacy_leftovers": [],
         "legacy_kill_commands": {},
         "legacy_unverified": [],
-        "legacy_command_unverified": [],
+        "superseded_ctl_unverified": [],
     }
     assert doc["ctl_windows"]["scan_error"] is None
 
diff --git a/tests/test_runs.py b/tests/test_runs.py
index 6035bc45..362a09e5 100644
--- a/tests/test_runs.py
+++ b/tests/test_runs.py
@@ -9212,6 +9212,28 @@ def boom():
     )
 
 
+def test_legacy_registry_leftovers_routes_own_registry_faults_apart(tmp_path, monkeypatch):
+    """#915: the project's own registry is no legacy one, so a fault in its scan
+    for the pre-upgrade control session goes to `on_primary_fault` when given,
+    not into the legacy fault list; without the hook it still lands there, so
+    no caller loses it. Ablate the routing and the first half fails."""
+
+    class _Unlistable(_RegistryMux):
+        def list_sessions_reporting(self, *, on_fault=None):
+            raise MultiplexerError("no server")
+
+    own = str(runs.mux_registry_root(tmp_path))
+    monkeypatch.setattr(runs, "_legacy_registries", lambda: [])
+    monkeypatch.setattr(runs, "get_multiplexer", lambda: _Unlistable([], {}, root=own))
+    routed: list[str] = []
+    assert runs.legacy_registry_leftovers(tmp_path, on_primary_fault=routed.append) == ({}, [])
+    assert routed == [f"{own}: could not be listed: no server"]
+    assert runs.legacy_registry_leftovers(tmp_path) == (
+        {},
+        [f"{own}: could not be listed: no server"],
+    )
+
+
 def test_superseded_ctl_may_be_run_when_a_run_has_the_id_its_name_spells(tmp_path, monkeypatch):
     """#915: a run dir whose session the transport resolves to the listed name
     means that name may be the run's own agent session; none means it cannot
diff --git a/tests/test_tui_app.py b/tests/test_tui_app.py
index 2749d713..2c405be4 100644
--- a/tests/test_tui_app.py
+++ b/tests/test_tui_app.py
@@ -3812,7 +3812,7 @@ async def test_cleanup_warns_about_sessions_left_in_the_legacy_registry(project,
     monkeypatch.setattr(
         runs,
         "legacy_registry_leftovers",
-        lambda _p: (
+        lambda _p, **_kw: (
             {
                 runs.DEFAULT_REGISTRY_LABEL: ["bmad-loop-ctl"],
                 r"D:	heir-own-registry": ["bmad-loop-old-1"],
@@ -3865,7 +3865,7 @@ async def test_cleanup_toast_names_another_projects_derived_registry(project, mo
     monkeypatch.setattr(runs, "prune_sessions", lambda _p: ([], [], set()))
     monkeypatch.setattr(launch, "prune_ctl_windows", lambda _p: ([], [], [], []))
     monkeypatch.setattr(
-        runs, "legacy_registry_leftovers", lambda _p: ({theirs: ["bmad-loop-ctl"]}, [])
+        runs, "legacy_registry_leftovers", lambda _p, **_kw: ({theirs: ["bmad-loop-ctl"]}, [])
     )
     make_run(project.project, "20260611-100000-aaaa")
     app = BmadLoopApp(project.project)
@@ -3898,7 +3898,7 @@ async def test_cleanup_warns_about_a_legacy_registry_that_could_not_be_asked(pro
     monkeypatch.setattr(
         runs,
         "legacy_registry_leftovers",
-        lambda _p: ({}, ["/reg/broken: could not be listed: no server"]),
+        lambda _p, **_kw: ({}, ["/reg/broken: could not be listed: no server"]),
     )
     make_run(project.project, "20260611-100000-aaaa")
     app = BmadLoopApp(project.project)