diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9e16144f4..37bf82e6c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -88,6 +88,15 @@ 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).
 - 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..6ff1c3448 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
@@ -202,9 +207,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 +220,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..595b3d15f 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), `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 9b6b7e312..4c35e9b95 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,53 @@ 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".
+
+    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:
+        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:
+        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; {where}",
+            file=sys.stderr,
+        )
+
+
 def cmd_attach(args: argparse.Namespace) -> int:
     from .tui import launch  # import-safe: launch.py has no textual imports
 
@@ -6464,6 +6517,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 +6706,80 @@ 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]]
+) -> 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
+    ``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."""
+    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)
+    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
+    }
+
+
+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), {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 +6813,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)
@@ -6720,6 +6860,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
@@ -6795,6 +6936,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,
             )
         )
@@ -6809,7 +6951,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)
         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 +6970,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)
     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..4ef5dd51c 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 = None,
     sessions_scan_error: str | None = None,
 ) -> dict[str, object]:
     """The `cleanup --json` document: the multiplexer artifacts this invocation
@@ -458,6 +459,14 @@ 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. 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 +487,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 097bfc1fd..6cdef1eb6 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
@@ -2488,9 +2525,91 @@ 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, 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 _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..e0c230b76 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 d8f6cf632..6ddc44775 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,142 @@ 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 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
+):
+    """#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 +7244,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 +7303,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"] == {
@@ -18736,6 +18875,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 +19644,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 —
@@ -19525,6 +19726,80 @@ 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
+):
+    """#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, _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_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
@@ -20199,6 +20474,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 39a367c09..0de615a85 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
diff --git a/tests/test_tui_app.py b/tests/test_tui_app.py
index 9b067d128..2749d7138 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