diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9e16144f4..41b9dd256 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -88,6 +88,20 @@ 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).
+- 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).
+- 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), 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 71b317be3..22d4125af 100644
--- a/docs/multiplexer-backends.md
+++ b/docs/multiplexer-backends.md
@@ -136,8 +136,17 @@ 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
+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 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; 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
@@ -202,9 +211,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 +224,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/docs/reference/cli.md b/docs/reference/cli.md
index 657923fd1..a2ec34835 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, `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 9b6b7e312..d720a432d 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,
             )
@@ -6428,6 +6434,69 @@ def cmd_list(args: argparse.Namespace) -> int:
     return 0
 
 
+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
+    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".
+
+    A paste-ready command only on psmux (``_is_psmux``); another backend's
+    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
+
+    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
+    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
+        how = where
+        if psmux:
+            verb = mux.attach_target_argv(f"={name}")[1]
+            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; {how}",
+            file=sys.stderr,
+        )
+
+
 def cmd_attach(args: argparse.Namespace) -> int:
     from .tui import launch  # import-safe: launch.py has no textual imports
 
@@ -6436,12 +6505,16 @@ 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)
     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.
@@ -6464,6 +6537,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
@@ -6652,8 +6726,110 @@ 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. psmux only (:func:`_is_psmux`)."""
+    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]], 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.
+
+    A command here and none for the other leftovers, because this session is
+    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. ``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.
+
+    ``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 check that could not be
+    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
+
+    try:
+        mux = get_multiplexer()
+        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 {}, []
+    # 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)
+    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 with that id may own it"
+
+
+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 "
+            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(
+            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), {how}",
+            file=sys.stderr,
+        )
+
+
 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 +6863,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)
@@ -6717,8 +6907,17 @@ 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,
+    )
+    kill_commands, ambiguous_ctl = _superseded_ctl_kill_commands(
+        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).
@@ -6795,7 +6994,9 @@ 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,
+                superseded_ctl_unverified=ctl_command_faults,
             )
         )
         return 0
@@ -6809,7 +7010,8 @@ 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)
+        _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
@@ -6827,7 +7029,8 @@ 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)
+    _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 8839bac6b..fae267cb6 100644
--- a/src/bmad_loop/documents.py
+++ b/src/bmad_loop/documents.py
@@ -397,7 +397,9 @@ 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 = None,
     sessions_scan_error: 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.
@@ -458,6 +460,25 @@ 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, 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 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. Additive, no
+    schema bump; the text mode prints each 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
     of this project is or may be alive (`runs.session_scan_error`). `removed` and
@@ -478,6 +499,8 @@ 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 {}),
+        "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 097bfc1fd..08967303a 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
@@ -2334,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
@@ -2450,9 +2490,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()
@@ -2488,9 +2535,142 @@ 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). 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: primary_fault(f"{label}: {msg}")
+        )
+    except MultiplexerError as exc:
+        primary_fault(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, 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]}"
+
+
+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.
+
+    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:
+        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 derive the pre-upgrade control-session name: {exc}")
+        return []
+    return sorted(
+        name
+        for name in mux.list_sessions_reporting(on_fault=on_fault)
+        if mux.session_name_key(name) == old
+    )
+
+
+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 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
+    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.
+
+    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):
+        entries = []
+    except OSError as exc:
+        return _fault("runs dir", exc)
+    if any(mux.session_name_key(session_name(run_id)) == key for run_id in entries):
+        return True
+    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]:
     """Backends bound to registries this project's sessions may predate, or []
     (see :meth:`~.multiplexer.TerminalMultiplexer.legacy_registries`, which owns
diff --git a/src/bmad_loop/tui/app.py b/src/bmad_loop/tui/app.py
index 979608572..c21d653dc 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(
@@ -2108,6 +2121,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 d8f6cf632..b106ba43b 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,219 @@ 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(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
+
+    def registry_root(self):
+        return _OWN_REG
+
+    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 session_options(self, _option):
+        return {}
+
+    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_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
+
+    # 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
+):
+    """#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_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 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
+):
+    """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,7 +7321,9 @@ 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": [],
+        "superseded_ctl_unverified": [],
     }
     assert doc["ctl_windows"] == {
         "removed": ["sweep-fin-1"],
@@ -7165,7 +7381,9 @@ 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": [],
+        "superseded_ctl_unverified": [],
     }
     assert doc["ctl_windows"] == {
         "removed": [],
@@ -18736,6 +18954,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])
@@ -19354,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"]},
             [],
         ),
@@ -19377,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: ([], []))
 
@@ -19404,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"]]
@@ -19429,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: ([], [], [], []))
 
@@ -19462,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"],
@@ -19483,6 +19723,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=(), **_kw: (
+            {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 —
@@ -19496,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"],
@@ -19517,14 +19797,162 @@ 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
     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=(), **_kw: ({_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
+):
+    """#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=(), **_kw: (
+            {
+                # 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, _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
+    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_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=(), **_kw: ({_OWN_REG: [_DIGEST_CTL]}, []),
+    )
+    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)
+
+    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 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 `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
+    `_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=(), **_kw: ({_OWN_REG: [_DIGEST_CTL]}, []),
+    )
+    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)
+
+    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"]["superseded_ctl_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):
     """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
@@ -19536,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: ([], [], [], []))
 
@@ -20199,7 +20627,9 @@ def test_cleanup_json_unavailable_backend_without_evidence_is_unchanged(
         "live": [],
         "unverifiable_pid": [],
         "legacy_leftovers": [],
+        "legacy_kill_commands": {},
         "legacy_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 39a367c09..362a09e55 100644
--- a/tests/test_runs.py
+++ b/tests/test_runs.py
@@ -8899,6 +8899,230 @@ 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)
+
+
+_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
+
+    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_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) == []
+
+
+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, 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"
+    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]
+
+
+@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 _no_root(_p):
+            raise runs.StateRootError("no writable state root")
+
+        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) == []
+    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(
+    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
@@ -8967,6 +9191,105 @@ 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_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
+    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_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) == {}
diff --git a/tests/test_tui_app.py b/tests/test_tui_app.py
index 9b067d128..2c405be44 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"],
@@ -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, **_kw: ({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
@@ -3860,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)