Update dataset (part 2)

README.md

@@ -297,7 +297,7 @@ empty change scores 0, and the reference fix scores 1.0 with every criterion
 equal to the task's original grading. The folder contains the reference fixes
 and the hidden graders, as the rows of this dataset do.
 
-5 more (geode, kratos, open-xml-sdk, openfire, zettlr) are packaged and are being re-checked; they are added
+4 more (geode, kratos, open-xml-sdk, zettlr) are packaged and are being re-checked; they are added
 as each one passes.
 
 Nine tasks have no Harbor package yet: click, sequelize, druid and hooks (one criterion each

harbor/tasks/manifest.json

@@ -7,6 +7,7 @@
     "coredns_rewrite_svcb_opt",
     "epicyon_deleted_post_announce_cache_contract",
     "microblogpub_deleted_object_resurrect_lookup_contract",
+    "openfire_userdeleting_last_owner_contract",
     "rope_rename_all_reexport_owners_contract",
     "retained_top_level_names_keep_their_values",
     "umya_structural_edit_reference_owners_contract",

harbor/tasks/openfire_userdeleting_last_owner_contract/environment/Dockerfile

@@ -0,0 +1,18 @@
+FROM ec-swe-openfire:source-v9 AS sanitized
+USER root
+COPY sanitize.py capture.py capture_submission.py /opt/task-tools/
+RUN HUD_TELEMETRY_ENABLED=false HUD_CLI_ANALYTICS_ENABLED=0 /opt/hudvenv/bin/python /opt/task-tools/sanitize.py
+FROM scratch
+COPY --from=sanitized / /
+ENV PATH="/opt/java17/bin:/usr/bin:/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
+ENV LANG="C.UTF-8"
+ENV JAVA_HOME="/opt/java17"
+ENV JAVA_TOOL_OPTIONS="-XX:MaxRAMPercentage=40"
+ENV MAVEN_OPTS="-Xmx768m"
+ENV HOME="/tmp/agent-home"
+ENV GOCACHE="/tmp/agent-home/.cache/go-build"
+ENV HUD_TELEMETRY_ENABLED="false"
+ENV HUD_CLI_ANALYTICS_ENABLED="0"
+WORKDIR /workspace/repo
+USER 1000:1000
+CMD ["sleep", "infinity"]

harbor/tasks/openfire_userdeleting_last_owner_contract/environment/capture.py

@@ -0,0 +1,28 @@
+"""Capture a patch against protected baseline history inside the agent sandbox."""
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, "/opt/task-tools")
+from capture_submission import capture_submission  # noqa: E402
+
+with tempfile.TemporaryDirectory(prefix="capture-") as directory:
+    git_dir = Path(directory) / "git"
+    shutil.copytree("/opt/task-tools/baseline.git", git_dir)
+    os.environ.update(
+        GIT_DIR=str(git_dir),
+        GIT_WORK_TREE="/workspace/repo",
+        GIT_CONFIG_NOSYSTEM="1",
+        GIT_CONFIG_GLOBAL="/dev/null",
+    )
+    print(
+        json.dumps(
+            capture_submission(
+                Path("/workspace/repo"), Path("/workspace/submissions/submitted.patch")
+            )
+        )
+    )

harbor/tasks/openfire_userdeleting_last_owner_contract/environment/capture_submission.py

@@ -0,0 +1,157 @@
+"""Capture tracked and new SWE files without changing the agent's Git index."""
+
+import argparse
+import hashlib
+import json
+import os
+import shlex
+import subprocess
+import tempfile
+from pathlib import Path
+
+MAX_SUBMISSION_BYTES = 32 * 1024 * 1024
+
+
+def capture_submission(
+    repository: Path, output: Path, *, max_bytes: int = MAX_SUBMISSION_BYTES
+) -> dict[str, object]:
+    """Write a bounded binary patch including nonignored new files.
+
+    Parameters
+    ----------
+    repository : Path
+        Git checkout root. HEAD must remain the task's initial commit.
+    output : Path
+        Submission path outside the checkout. Replaces any prior submission.
+    max_bytes : int, default: 33554432
+        Maximum emitted patch size. Oversized submissions fail without a patch.
+
+    Returns
+    -------
+    dict
+        Patch size, SHA-256, base commit and capture format for trial evidence.
+
+    Raises
+    ------
+    ValueError
+        If paths or the limit are invalid, or the patch exceeds the limit.
+    OSError, subprocess.CalledProcessError, RuntimeError
+        If capture fails. No partial patch is published.
+
+    Notes
+    -----
+    Uses a temporary index to combine staged, unstaged and untracked changes.
+    Ignored untracked files are excluded. This is a capture bound, not a total
+    sandbox disk quota or a security boundary against a malicious Git runtime.
+    """
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int) or max_bytes < 1:
+        raise ValueError("max_bytes must be a positive integer")
+    repository = repository.resolve(strict=True)
+    if output.is_symlink():
+        raise ValueError("Submission output must not be a symlink")
+    output = output.resolve()
+    if output.is_relative_to(repository):
+        raise ValueError("Submission output must be outside the repository")
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.unlink(missing_ok=True)
+    root = subprocess.check_output(
+        ["git", "rev-parse", "--show-toplevel"], cwd=repository, text=True
+    ).strip()
+    if Path(root).resolve() != repository:
+        raise ValueError("repository must be the Git checkout root")
+    base = subprocess.check_output(
+        ["git", "rev-parse", "--verify", "HEAD^{commit}"], cwd=repository, text=True
+    ).strip()
+    with tempfile.TemporaryDirectory(prefix="submission-", dir=output.parent) as directory:
+        temporary = Path(directory)
+        env = {**os.environ, "GIT_INDEX_FILE": str(temporary / "index")}
+        for arguments in (["read-tree", base], ["add", "--all", "--", "."]):
+            subprocess.run(["git", *arguments], cwd=repository, env=env, check=True)
+        patch = temporary / "patch"
+        size = 0
+        digest = hashlib.sha256()
+        with (
+            patch.open("wb") as stream,
+            tempfile.TemporaryFile() as errors,
+            subprocess.Popen(
+                [
+                    "git",
+                    "diff",
+                    "--cached",
+                    "--binary",
+                    "--full-index",
+                    "--no-renames",
+                    "--no-ext-diff",
+                    "--no-textconv",
+                    "--no-color",
+                    "--src-prefix=a/",
+                    "--dst-prefix=b/",
+                    base,
+                ],
+                cwd=repository,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=errors,
+            ) as process,
+        ):
+            assert process.stdout is not None
+            try:
+                while chunk := process.stdout.read(65536):
+                    size += len(chunk)
+                    if size > max_bytes:
+                        raise ValueError(f"Submission exceeds {max_bytes} bytes")
+                    stream.write(chunk)
+                    digest.update(chunk)
+            except BaseException:
+                process.kill()
+                process.wait()
+                raise
+            if process.wait():
+                errors.seek(0)
+                raise RuntimeError(
+                    "Git patch capture failed: " + errors.read(4096).decode(errors="replace")
+                )
+        patch.replace(output)
+    return {
+        "bytes": size,
+        "sha256": digest.hexdigest(),
+        "base_commit": base,
+        "format": "git-binary-v1",
+    }
+
+
+def submission_command(*, max_bytes: int = MAX_SUBMISSION_BYTES) -> str:
+    """Build the trusted command recorded before Harbor collects artifacts.
+
+    Parameters
+    ----------
+    max_bytes : int, default: 33554432
+        Maximum emitted patch bytes.
+
+    Returns
+    -------
+    str
+        Shell command carrying this exact helper into the solver runtime.
+
+    Raises
+    ------
+    ValueError
+        If the size limit is invalid.
+    """
+    if isinstance(max_bytes, bool) or not isinstance(max_bytes, int) or max_bytes < 1:
+        raise ValueError("max_bytes must be a positive integer")
+    return "python -c " + shlex.quote(Path(__file__).read_text()) + f" --max-bytes {max_bytes}"
+
+
+def main() -> None:
+    """Capture the submission and print its identity as trial evidence."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repository", type=Path, default=Path("/testbed"))
+    parser.add_argument("--output", type=Path, default=Path("/workspace/submitted.patch"))
+    parser.add_argument("--max-bytes", type=int, default=MAX_SUBMISSION_BYTES)
+    args = parser.parse_args()
+    print(json.dumps(capture_submission(args.repository, args.output, max_bytes=args.max_bytes)))
+
+
+if __name__ == "__main__":
+    main()

harbor/tasks/openfire_userdeleting_last_owner_contract/environment/docker-compose.yaml

@@ -0,0 +1,11 @@
+services:
+  main:
+    pids_limit: 512
+    security_opt:
+      - no-new-privileges:true
+    volumes:
+      - type: tmpfs
+        target: /logs/verifier
+        tmpfs:
+          mode: 448
+          size: 1048576

harbor/tasks/openfire_userdeleting_last_owner_contract/environment/sanitize.py

@@ -0,0 +1,25 @@
+"""Remove private task assets and history when building the agent-only image."""
+
+import asyncio
+import os
+import shutil
+import sys
+from pathlib import Path
+
+sys.path.insert(0, "/app")
+from env import _setup  # noqa: E402
+
+asyncio.run(_setup())
+# The new history contains only the public baseline. Preserve a root-owned
+# copy so capture can ignore agent-controlled refs, hooks and Git configuration.
+shutil.copytree("/workspace/repo/.git", "/opt/task-tools/baseline.git")
+for path in Path("/opt/task-tools/baseline.git").rglob("*"):
+    os.chown(path, 0, 0)
+    path.chmod(0o755 if path.is_dir() else 0o644)
+for name in ("/hud", "/app", "/root/.cache", "/root/.hud"):
+    if Path(name).exists():
+        shutil.rmtree(name)
+# Capture runs on the base interpreter under one name, whatever the image calls it.
+os.symlink(os.path.realpath(sys.executable), "/opt/task-tools/python")
+Path("/workspace/submissions").mkdir()
+os.chown("/workspace/submissions", 1000, 1000)

harbor/tasks/openfire_userdeleting_last_owner_contract/instruction.md

@@ -0,0 +1,23 @@
+Please make your changes directly in /workspace/repo.
+
+Deleting a user account keeps leaving chat rooms in a state we cannot get out of.
+
+The first report was a room whose single owner left the company. Her account was removed, and every
+attempt to change the room's configuration is now refused, the room's admins included: there is no
+owner left, so nobody can appoint one. A restart does not help. A room owned by a shared group ended
+up the same way once that group had nobody left in it: the room still names the group, and there
+is nobody behind it.
+
+The departed name also stays behind. It is still written against rooms it owned and rooms it merely
+belonged to, and it never left the chat service's own settings: when somebody recreated a departed
+colleague's account under the same name, the service, running since before the deletion, greeted
+the newcomer as its administrator - owner of any room, and able to create rooms where the rest of us
+cannot.
+
+Who takes a room over is your call. Keep the change to that: apart from the account that is
+leaving, and whoever has to take over a room that would otherwise have no owner, every room and
+every service setting comes out exactly as it went in.
+
+Leave the test files that ship with the repository byte for byte as they are; add your own.
+
+Finish with a final response when your changes are ready.

harbor/tasks/openfire_userdeleting_last_owner_contract/solution/reference.patch

@@ -0,0 +1,1304 @@
+diff --git a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MUCRoom.java b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MUCRoom.java
+index b569890..043dc8d 100644
+--- a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MUCRoom.java
++++ b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MUCRoom.java
+@@ -4120,7 +4120,9 @@ public class MUCRoom implements GroupEventListener, UserEventListener, Externali
+ 
+     @Override
+     public void memberRemoved(Group group, Map<String, ?> params) {
+-        applyAffiliationChangeAndSendPresence(new JID((String)params.get("member")));
++        final JID member = new JID((String)params.get("member"));
++        applyAffiliationChangeAndSendPresence(member);
++        keepAnOwnerAfterGroupChange(group, member);
+     }
+ 
+     @Override
+@@ -4130,7 +4132,44 @@ public class MUCRoom implements GroupEventListener, UserEventListener, Externali
+ 
+     @Override
+     public void adminRemoved(Group group, Map<String, ?> params) {
+-        applyAffiliationChangeAndSendPresence(new JID((String)params.get("admin")));
++        final JID admin = new JID((String)params.get("admin"));
++        applyAffiliationChangeAndSendPresence(admin);
++        keepAnOwnerAfterGroupChange(group, admin);
++    }
++
++    /**
++     * A shared group can own this room. When the last person is taken out of such a group, nobody is left who can
++     * administer the room - the same state that deleting its last owner leaves behind - so the room is given a new owner
++     * here. Rooms that are not in memory are seen to by MultiUserChatManager.
++     *
++     * @param group The group that somebody was taken out of.
++     * @param removed The address that was taken out of the group. It is not handed the room: it was just taken out of
++     *                the group that owned it.
++     */
++    private void keepAnOwnerAfterGroupChange(@Nonnull final Group group, @Nullable final JID removed)
++    {
++        if (!owners.contains(group.getJID())) {
++            return;
++        }
++        final Lock lock = getMUCService().getChatRoomLock(getJID().getNode());
++        lock.lock();
++        try {
++            if (hasOwnerOtherThan(null)) {
++                return;
++            }
++            final JID replacementJid = findReplacementOwner(removed);
++            if (replacementJid == null) {
++                Log.warn("The last person was taken out of group '{}', which owns MUC room '{}', but no account could be found to take over ownership of the room.", group.getName(), getJID());
++                return;
++            }
++            Log.info("The last person was taken out of group '{}', which owns MUC room '{}'. To prevent having a room without owner, '{}' was made owner of the room.", group.getName(), getJID(), replacementJid);
++            addOwner(replacementJid, getSelfRepresentation().getAffiliation());
++            getMUCService().syncChatRoom(this);
++        } catch (Throwable t) {
++            Log.warn("A problem occurred while trying to keep an owner for room '{}' after group '{}' lost a member.", getJID(), group.getName(), t);
++        } finally {
++            lock.unlock();
++        }
+     }
+ 
+     private void applyAffiliationChangeAndSendPresence(JID groupMember) {
+@@ -4161,21 +4200,33 @@ public class MUCRoom implements GroupEventListener, UserEventListener, Externali
+         try {
+             lock.lock();
+ 
+-            if (getAffiliation(userJid) == Affiliation.none) {
+-                // User had no affiliation with this room.
+-                return;
++            final boolean wasAffiliated = getAffiliation(userJid) != Affiliation.none;
++
++            // Cannot remove the last owner of a chat room. To prevent issues, replace the owner with an administrative
++            // account. Note that ownership can be held through a shared group, in which case this room loses its last
++            // owner when that group loses its last member - which is the same event, reaching this room through a user
++            // that this room does not list at all.
++            boolean roomChanged = false;
++            if (isLeftWithoutOwnerBy(userJid)) {
++                final JID replacementJid = findReplacementOwner(userJid);
++                if (replacementJid == null) {
++                    Log.warn("User '{}' is being deleted, and is the last owner of MUC room '{}', but no account could be found to take over ownership of the room.", user.getUsername(), getJID());
++                } else {
++                    Log.info("User '{}' is being deleted, but is also the only owner of MUC room '{}'. To prevent having a room without owner, '{}' was made owner of the room.", user.getUsername(), getJID(), replacementJid);
++                    addOwner(replacementJid, getSelfRepresentation().getAffiliation());
++                    roomChanged = true;
++                }
+             }
+ 
+-            // Cannot remove the last owner of a chat room. To prevent issues, replace the owner with an administrative account.
+-            if (getOwners().contains(userJid) && getOwners().size() == 1) {
+-                final JID adminJid = XMPPServer.getInstance().getAdmins().iterator().next();
+-                Log.info("User '{}' is being deleted, but is also the only owner of MUC room '{}'. To prevent having a room without owner, server admin '{}' was made owner of the room.", user.getUsername(), getJID(), adminJid);
+-                addOwner(adminJid, getSelfRepresentation().getAffiliation());
++            if (wasAffiliated) {
++                // Remove the affiliation of the deleted user with the room
++                addNone(userJid, getSelfRepresentation().getAffiliation());
++                roomChanged = true;
+             }
+ 
+-            // Remove the affiliation of the deleted user with the room
+-            addNone(userJid, getSelfRepresentation().getAffiliation());
+-            getMUCService().syncChatRoom(this);
++            if (roomChanged) {
++                getMUCService().syncChatRoom(this);
++            }
+         } catch (Throwable t) {
+             Log.warn("A problem occurred while trying to update room '{}' as a result of user '{}' being deleted from Openfire.", getJID(), user);
+         } finally {
+@@ -4183,6 +4234,107 @@ public class MUCRoom implements GroupEventListener, UserEventListener, Externali
+         }
+     }
+ 
++    /**
++     * Checks if the removal of the provided address leaves this room without an owner that stands for an existing
++     * account.
++     *
++     * A room whose owner entries never stood for the address that is going, and could not have been emptied by its
++     * departure either, is not left without an owner by this deletion: whatever state it is in, it was in before, and
++     * giving it a new owner here would change a room that this deletion did not touch. An owner entry that names a
++     * shared group that no longer exists is such a case - deleting a user does not delete groups.
++     *
++     * @param excludedAddress The (real) JID that is going.
++     * @return true if this room is about to be left without anyone that can administer it, otherwise false.
++     */
++    private boolean isLeftWithoutOwnerBy(@Nonnull final JID excludedAddress)
++    {
++        if (hasOwnerOtherThan(excludedAddress)) {
++            return false;
++        }
++        final JID excluded = excludedAddress.asBareJID();
++        for (final JID owner : owners) {
++            if (GroupJID.isGroup(owner)) {
++                try {
++                    GroupManager.getInstance().getGroup(owner);
++                    return true;
++                } catch (GroupNotFoundException e) {
++                    Log.debug("Room '{}' is owned by group '{}', which no longer exists.", getJID(), owner, e);
++                }
++            } else if (excluded.equals(owner.asBareJID())) {
++                return true;
++            }
++        }
++        return false;
++    }
++
++    /**
++     * Checks if this room has an owner other than the provided address. An owner that is held through a shared group
++     * counts only when that group still has a member other than the provided address: a group without members leaves
++     * the room without anyone that can administer it, exactly like an empty list of owners does.
++     *
++     * @param excludedAddress The (real) JID that is not to be taken into account, or null to count every owner.
++     * @return true if another account owns this room, otherwise false.
++     */
++    private boolean hasOwnerOtherThan(@Nullable final JID excludedAddress)
++    {
++        final JID excluded = excludedAddress == null ? null : excludedAddress.asBareJID();
++        for (final JID owner : owners) {
++            if (GroupJID.isGroup(owner)) {
++                try {
++                    for (final JID groupMember : GroupManager.getInstance().getGroup(owner).getAll()) {
++                        if (!groupMember.asBareJID().equals(excluded)) {
++                            return true;
++                        }
++                    }
++                } catch (GroupNotFoundException e) {
++                    Log.debug("Room '{}' is owned by group '{}', which no longer exists.", getJID(), owner, e);
++                }
++            } else if (!owner.asBareJID().equals(excluded)) {
++                return true;
++            }
++        }
++        return false;
++    }
++
++    /**
++     * Finds an account that can take over ownership of this room: a server administrator when there is one, and
++     * otherwise someone that this room already trusts.
++     *
++     * @param excludedAddress The (real) JID that is not to be selected (typically: a user that is being deleted), or null.
++     * @return the address of the new owner, or null when no suitable account exists.
++     */
++    @Nullable
++    private JID findReplacementOwner(@Nullable final JID excludedAddress)
++    {
++        final List<Collection<JID>> candidateLists = new ArrayList<>();
++        candidateLists.add(XMPPServer.getInstance().getAdmins());
++        candidateLists.add(new ArrayList<>(admins));
++        candidateLists.add(getMembers());
++
++        final JID excluded = excludedAddress == null ? null : excludedAddress.asBareJID();
++        for (final Collection<JID> candidates : candidateLists) {
++            for (final JID candidate : candidates) {
++                if (candidate == null) {
++                    continue;
++                }
++                if (GroupJID.isGroup(candidate)) {
++                    try {
++                        for (final JID groupMember : GroupManager.getInstance().getGroup(candidate).getAll()) {
++                            if (!groupMember.asBareJID().equals(excluded)) {
++                                return groupMember.asBareJID();
++                            }
++                        }
++                    } catch (GroupNotFoundException e) {
++                        Log.debug("Room '{}' refers to group '{}', which no longer exists.", getJID(), candidate, e);
++                    }
++                } else if (!candidate.asBareJID().equals(excluded)) {
++                    return candidate.asBareJID();
++                }
++            }
++        }
++        return null;
++    }
++
+     @Override
+     public void userModified(User user, Map<String, Object> params)
+     {}
+diff --git a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MultiUserChatManager.java b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MultiUserChatManager.java
+index 475aef7..def4314 100644
+--- a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MultiUserChatManager.java
++++ b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MultiUserChatManager.java
+@@ -20,8 +20,11 @@ import org.jivesoftware.database.DbConnectionManager;
+ import org.jivesoftware.database.SequenceManager;
+ import org.jivesoftware.openfire.XMPPServer;
+ import org.jivesoftware.openfire.container.BasicModule;
++import org.jivesoftware.openfire.event.GroupEventDispatcher;
++import org.jivesoftware.openfire.event.GroupEventListener;
+ import org.jivesoftware.openfire.event.UserEventDispatcher;
+ import org.jivesoftware.openfire.event.UserEventListener;
++import org.jivesoftware.openfire.group.Group;
+ import org.jivesoftware.openfire.muc.cluster.ServiceAddedEvent;
+ import org.jivesoftware.openfire.muc.cluster.ServiceRemovedEvent;
+ import org.jivesoftware.openfire.muc.cluster.ServiceUpdatedEvent;
+@@ -54,7 +57,7 @@ import java.util.stream.Collectors;
+  * @author Daniel Henninger
+  */
+ public class MultiUserChatManager extends BasicModule implements MUCServicePropertyEventListener,
+-        UserEventListener {
++        UserEventListener, GroupEventListener {
+ 
+     private static final Logger Log = LoggerFactory.getLogger(MultiUserChatManager.class);
+ 
+@@ -140,6 +143,7 @@ public class MultiUserChatManager extends BasicModule implements MUCServicePrope
+         addNumberOutgoingMessages();
+ 
+         UserEventDispatcher.addListener(this);
++        GroupEventDispatcher.addListener(this);
+         MUCServicePropertyEventDispatcher.addListener(this);
+     }
+ 
+@@ -151,6 +155,7 @@ public class MultiUserChatManager extends BasicModule implements MUCServicePrope
+         super.stop();
+ 
+         UserEventDispatcher.removeListener(this);
++        GroupEventDispatcher.removeListener(this);
+         MUCServicePropertyEventDispatcher.removeListener(this);
+ 
+         // Remove the statistics.
+@@ -1200,8 +1205,20 @@ public class MultiUserChatManager extends BasicModule implements MUCServicePrope
+         // When a user is being deleted, all its affiliations need to be removed from chat rooms (OF-2166). Note that
+         // every room is an event listener for the same event, which should update rooms that are loaded into memory
+         // from the database. This event handler intends to update rooms that are not in memory, but only in the database.
+-        MUCPersistenceManager
+-                .removeAffiliationFromDB(XMPPServer.getInstance().createJID(user.getUsername(), null, true));
++        final JID userJID = XMPPServer.getInstance().createJID(user.getUsername(), null, true);
++
++        // Apart from the affiliations that are recorded per room, each service records the users that administer it
++        // and the users that are allowed to create rooms on it. A user that no longer exists should be in neither.
++        for (final MultiUserChatService service : getMultiUserChatServices()) {
++            try {
++                service.removeSysadmin(userJID);
++                service.removeUserAllowedToCreate(userJID);
++            } catch (Exception e) {
++                Log.warn("A problem occurred while trying to update MUC service '{}' as a result of user '{}' being deleted from Openfire.", service.getServiceName(), user, e);
++            }
++        }
++
++        MUCPersistenceManager.removeAffiliationFromDB(userJID);
+     }
+ 
+     @Override
+@@ -1209,6 +1226,68 @@ public class MultiUserChatManager extends BasicModule implements MUCServicePrope
+         // Do nothing
+     }
+ 
++    @Override
++    public void groupCreated(Group group, Map<String, ?> params) {
++        // Do nothing
++    }
++
++    @Override
++    public void groupDeleting(Group group, Map<String, ?> params) {
++        // Do nothing
++    }
++
++    @Override
++    public void groupModified(Group group, Map<String, ?> params) {
++        // Do nothing
++    }
++
++    @Override
++    public void memberAdded(Group group, Map<String, ?> params) {
++        // Do nothing
++    }
++
++    @Override
++    public void memberRemoved(Group group, Map<String, ?> params) {
++        keepAnOwnerForRoomsOwnedBy(group, (String) params.get("member"));
++    }
++
++    @Override
++    public void adminAdded(Group group, Map<String, ?> params) {
++        // Do nothing
++    }
++
++    @Override
++    public void adminRemoved(Group group, Map<String, ?> params) {
++        keepAnOwnerForRoomsOwnedBy(group, (String) params.get("admin"));
++    }
++
++    /**
++     * A shared group can own chat rooms. When the last person is taken out of such a group, nobody is left who can
++     * administer those rooms - the same state that deleting their last owner leaves behind. Rooms that are in memory
++     * listen to the group's events themselves; this sees to the rooms that are only in the database.
++     *
++     * @param group The group that somebody was taken out of.
++     * @param removed The address that was taken out of the group (as the event reports it), or null.
++     */
++    private void keepAnOwnerForRoomsOwnedBy(@Nonnull final Group group, @Nullable final String removed)
++    {
++        try {
++            if (!group.getAll().isEmpty()) {
++                return;
++            }
++            final Set<Long> roomsInMemory = new HashSet<>();
++            for (final MultiUserChatService service : getMultiUserChatServices()) {
++                for (final MUCRoom room : service.getActiveChatRooms()) {
++                    roomsInMemory.add(room.getID());
++                }
++            }
++            MUCPersistenceManager.keepAnOwnerForRoomsOwnedBy(group.getJID(),
++                removed == null ? null : new JID(removed).asBareJID(), roomsInMemory);
++        } catch (Exception e) {
++            Log.warn("A problem occurred while trying to keep an owner for the rooms owned by group '{}' after somebody was taken out of it.", group.getName(), e);
++        }
++    }
++
+     private static class ServiceComparator implements Comparator<MultiUserChatService> {
+         @Override
+         public int compare(MultiUserChatService o1, MultiUserChatService o2) {
+diff --git a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/spi/MUCPersistenceManager.java b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/spi/MUCPersistenceManager.java
+index bc64ae4..83a7373 100644
+--- a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/spi/MUCPersistenceManager.java
++++ b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/spi/MUCPersistenceManager.java
+@@ -21,6 +21,8 @@ import org.dom4j.Element;
+ import org.jivesoftware.database.DbConnectionManager;
+ import org.jivesoftware.openfire.XMPPServer;
+ import org.jivesoftware.openfire.group.GroupJID;
++import org.jivesoftware.openfire.group.GroupManager;
++import org.jivesoftware.openfire.group.GroupNotFoundException;
+ import org.jivesoftware.openfire.muc.*;
+ import org.jivesoftware.util.JiveGlobals;
+ import org.jivesoftware.util.NamedThreadFactory;
+@@ -170,6 +172,12 @@ public class MUCPersistenceManager {
+         "DELETE FROM ofMucMember WHERE jid=?";
+     private static final String DELETE_USER_MUCAFFILIATION =
+         "DELETE FROM ofMucAffiliation WHERE jid=?";
++    private static final String LOAD_ALL_AFFILIATIONS_OF_KIND =
++        "SELECT roomID,jid FROM ofMucAffiliation WHERE affiliation=?";
++    private static final String LOAD_ROOM_AFFILIATIONS_OF_KIND =
++        "SELECT jid FROM ofMucAffiliation WHERE roomID=? AND affiliation=? ORDER BY jid";
++    private static final String LOAD_ROOM_MEMBERS =
++        "SELECT jid FROM ofMucMember WHERE roomID=? ORDER BY jid";
+     private static final String ADD_CONVERSATION_LOG =
+         "INSERT INTO ofMucConversationLog (roomID,messageID,sender,nickname,logTime,subject,body,stanza) VALUES (?,?,?,?,?,?,?,?)";
+     private static final String DELETE_ROOM_HISTORY =
+@@ -1369,6 +1377,21 @@ public class MUCPersistenceManager {
+         PreparedStatement pstmt = null;
+         try {
+             con = DbConnectionManager.getConnection();
++
++            // Rooms that are not in memory have no event listener of their own: a room that is left without an owner
++            // by the removal below has to be given a new owner here. Ownership can be held through a shared group, so
++            // a room whose only owner is a group that no longer has members is in the same position as a room whose
++            // only owner is the user that is being deleted.
++            for (final Long roomID : roomsLeftWithoutOwnerBy(con, affiliationJID)) {
++                final JID replacementJID = findReplacementOwner(con, roomID, affiliationJID);
++                if (replacementJID == null) {
++                    Log.warn("User '{}' is being deleted, and is the last owner of MUC room with ID {}, but no account could be found to take over ownership of the room.", affiliationJID, roomID);
++                } else {
++                    Log.info("User '{}' is being deleted, but is also the only owner of MUC room with ID {}. To prevent having a room without owner, '{}' was made owner of the room.", affiliationJID, roomID, replacementJID);
++                    saveOwnerToDB(con, roomID, replacementJID);
++                }
++            }
++
+             // Remove the user from the members table
+             pstmt = con.prepareStatement(DELETE_USER_MEMBER);
+             pstmt.setString(1, affiliationJID.toBareJID());
+@@ -1388,6 +1411,247 @@ public class MUCPersistenceManager {
+         }
+     }
+ 
++    /**
++     * Returns the IDs of the persistent rooms that the removal of the provided address leaves without an owner that
++     * refers to an existing account. An owner entry that is a shared group counts only when that group still has a
++     * member other than the provided address.
++     *
++     * A room whose owner entries never stood for the address that is going, and could not have been emptied by its
++     * departure either, is none of this method's business: it was already in whatever state it is in before this
++     * deletion, and handing it a new owner here would change a room that this deletion did not touch.
++     *
++     * @param con an open database connection.
++     * @param excludedJID The (real) JID that is not to be taken into account (typically: a user that is being deleted).
++     * @return the IDs of the rooms that are about to be left without an owner.
++     * @throws SQLException when the affiliations could not be read.
++     */
++    private static Collection<Long> roomsLeftWithoutOwnerBy(Connection con, JID excludedJID) throws SQLException
++    {
++        final Map<Long, Boolean> hasOtherOwner = new LinkedHashMap<>();
++        final Map<Long, Boolean> concerned = new LinkedHashMap<>();
++        try (final PreparedStatement pstmt = con.prepareStatement(LOAD_ALL_AFFILIATIONS_OF_KIND)) {
++            pstmt.setInt(1, Affiliation.owner.getValue());
++            try (final ResultSet rs = pstmt.executeQuery()) {
++                while (rs.next()) {
++                    final long roomID = rs.getLong(1);
++                    final String storedJID = rs.getString(2);
++                    hasOtherOwner.merge(roomID, isAccountOtherThan(storedJID, excludedJID), Boolean::logicalOr);
++                    concerned.merge(roomID, couldHaveLostItsAccount(storedJID, excludedJID), Boolean::logicalOr);
++                }
++            }
++        }
++
++        final List<Long> result = new ArrayList<>();
++        for (final Map.Entry<Long, Boolean> entry : hasOtherOwner.entrySet()) {
++            if (!entry.getValue() && Boolean.TRUE.equals(concerned.get(entry.getKey()))) {
++                result.add(entry.getKey());
++            }
++        }
++        return result;
++    }
++
++    /**
++     * Checks if an owner entry can have stopped standing for an existing account through the removal of the provided
++     * address: the entry is that address, or it is a shared group that still exists - a group that is empty now may
++     * have just lost its last member, and that member may have been the address that is going.
++     *
++     * An entry that names a shared group that no longer exists cannot have been emptied here, because deleting a user
++     * does not delete groups. Such an entry had already stopped standing for anybody before this deletion started.
++     */
++    private static boolean couldHaveLostItsAccount(String storedJID, JID excludedJID)
++    {
++        if (storedJID == null || storedJID.isEmpty()) {
++            return false;
++        }
++        final JID stored = new JID(storedJID);
++        if (GroupJID.isGroup(stored)) {
++            try {
++                GroupManager.getInstance().getGroup(stored);
++                return true;
++            } catch (GroupNotFoundException e) {
++                Log.debug("A MUC room is affiliated with group '{}', which no longer exists.", storedJID, e);
++                return false;
++            }
++        }
++        return excludedJID.asBareJID().equals(stored.asBareJID());
++    }
++
++    /**
++     * Finds an account that can take over ownership of a room that is not in memory: a server administrator when there
++     * is one, and otherwise someone that the room already trusts.
++     *
++     * @param con an open database connection.
++     * @param roomID The ID of the room that needs a new owner.
++     * @param excludedJID The (real) JID that is not to be selected (typically: a user that is being deleted).
++     * @return the address of the new owner, or null when no suitable account exists.
++     * @throws SQLException when the affiliations could not be read.
++     */
++    private static JID findReplacementOwner(Connection con, Long roomID, JID excludedJID) throws SQLException
++    {
++        final List<String> candidates = new ArrayList<>();
++        for (final JID admin : XMPPServer.getInstance().getAdmins()) {
++            candidates.add(admin.toBareJID());
++        }
++        try (final PreparedStatement pstmt = con.prepareStatement(LOAD_ROOM_AFFILIATIONS_OF_KIND)) {
++            pstmt.setLong(1, roomID);
++            pstmt.setInt(2, Affiliation.admin.getValue());
++            try (final ResultSet rs = pstmt.executeQuery()) {
++                while (rs.next()) {
++                    candidates.add(rs.getString(1));
++                }
++            }
++        }
++        try (final PreparedStatement pstmt = con.prepareStatement(LOAD_ROOM_MEMBERS)) {
++            pstmt.setLong(1, roomID);
++            try (final ResultSet rs = pstmt.executeQuery()) {
++                while (rs.next()) {
++                    candidates.add(rs.getString(1));
++                }
++            }
++        }
++
++        for (final String candidate : candidates) {
++            final JID resolved = resolveToAccountOtherThan(candidate, excludedJID);
++            if (resolved != null) {
++                return resolved;
++            }
++        }
++        return null;
++    }
++
++    /**
++     * Stores an owner affiliation for a room, replacing whatever affiliation that address had in that room before.
++     *
++     * @param con an open database connection.
++     * @param roomID The ID of the room.
++     * @param ownerJID The address that is to own the room.
++     * @throws SQLException when the affiliation could not be written.
++     */
++    private static void saveOwnerToDB(Connection con, Long roomID, JID ownerJID) throws SQLException
++    {
++        // An owner is not a member: the room's own code drops the membership when it promotes someone
++        // (MUCRoom#addOwner), and so does the affiliation that is written per room. Leaving the membership behind
++        // would store the same address as owner and as member at once, which no other path in this class produces,
++        // which a reload does not clean up, and which makes a later demotion collide on the membership's key.
++        try (final PreparedStatement pstmt = con.prepareStatement(DELETE_MEMBER)) {
++            pstmt.setLong(1, roomID);
++            pstmt.setString(2, ownerJID.toBareJID());
++            pstmt.executeUpdate();
++        }
++        try (final PreparedStatement pstmt = con.prepareStatement(UPDATE_AFFILIATION)) {
++            pstmt.setInt(1, Affiliation.owner.getValue());
++            pstmt.setLong(2, roomID);
++            pstmt.setString(3, ownerJID.toBareJID());
++            if (pstmt.executeUpdate() > 0) {
++                return;
++            }
++        }
++        try (final PreparedStatement pstmt = con.prepareStatement(ADD_AFFILIATION)) {
++            pstmt.setLong(1, roomID);
++            pstmt.setString(2, ownerJID.toBareJID());
++            pstmt.setInt(3, Affiliation.owner.getValue());
++            pstmt.executeUpdate();
++        }
++    }
++
++    /**
++     * Checks if a stored affiliation entry refers to an existing account other than the provided address. Entries that
++     * refer to a shared group are resolved to the members of that group.
++     */
++    private static boolean isAccountOtherThan(String storedJID, JID excludedJID)
++    {
++        return resolveToAccountOtherThan(storedJID, excludedJID) != null;
++    }
++
++    /**
++     * Resolves a stored affiliation entry to an existing account other than the provided address. Entries that refer to
++     * a shared group are resolved to the first member of that group that qualifies.
++     *
++     * @return the address of a qualifying account, or null when the entry refers to none.
++     */
++    private static JID resolveToAccountOtherThan(String storedJID, JID excludedJID)
++    {
++        if (storedJID == null || storedJID.isEmpty()) {
++            return null;
++        }
++        final JID excluded = excludedJID == null ? null : excludedJID.asBareJID();
++        final JID stored = new JID(storedJID);
++        if (GroupJID.isGroup(stored)) {
++            try {
++                for (final JID groupMember : GroupManager.getInstance().getGroup(stored).getAll()) {
++                    if (!groupMember.asBareJID().equals(excluded)) {
++                        return groupMember.asBareJID();
++                    }
++                }
++            } catch (GroupNotFoundException e) {
++                Log.debug("A MUC room is affiliated with group '{}', which no longer exists.", storedJID, e);
++            }
++            return null;
++        }
++        return stored.asBareJID().equals(excluded) ? null : stored.asBareJID();
++    }
++
++    /**
++     * Gives an owner to every persistent room that is not in memory, that is owned by the provided shared group, and
++     * that has no owner left that refers to an existing account. This is what taking the last person out of a group
++     * does to the rooms that the group owns: nobody is left who can administer them. Rooms that are in memory see to
++     * this themselves (they listen to the group's events).
++     *
++     * @param groupJID The address of the group that somebody was taken out of.
++     * @param removedJID The address that was taken out of the group (it is not handed a room), or null.
++     * @param roomsInMemory The IDs of the rooms that are in memory, which are left alone here.
++     */
++    public static void keepAnOwnerForRoomsOwnedBy(@Nonnull final JID groupJID, @Nullable final JID removedJID,
++                                                  @Nonnull final Collection<Long> roomsInMemory)
++    {
++        try (final Connection con = DbConnectionManager.getConnection()) {
++            for (final Long roomID : roomsOwnedByWithoutAnOwner(con, groupJID)) {
++                if (roomsInMemory.contains(roomID)) {
++                    continue;
++                }
++                final JID replacementJID = findReplacementOwner(con, roomID, removedJID);
++                if (replacementJID == null) {
++                    Log.warn("The last person was taken out of group '{}', which owns MUC room with ID {}, but no account could be found to take over ownership of the room.", groupJID, roomID);
++                } else {
++                    Log.info("The last person was taken out of group '{}', which owns MUC room with ID {}. To prevent having a room without owner, '{}' was made owner of the room.", groupJID, roomID, replacementJID);
++                    saveOwnerToDB(con, roomID, replacementJID);
++                }
++            }
++        } catch (SQLException sqle) {
++            Log.error("A database error occurred while trying to give an owner to the rooms owned by group '{}'.", groupJID, sqle);
++        }
++    }
++
++    /**
++     * Returns the IDs of the persistent rooms that are owned by the provided group and that have no owner entry left
++     * that refers to an existing account.
++     */
++    private static Collection<Long> roomsOwnedByWithoutAnOwner(Connection con, JID groupJID) throws SQLException
++    {
++        final Map<Long, Boolean> hasOwner = new LinkedHashMap<>();
++        final Set<Long> ownedByGroup = new HashSet<>();
++        try (final PreparedStatement pstmt = con.prepareStatement(LOAD_ALL_AFFILIATIONS_OF_KIND)) {
++            pstmt.setInt(1, Affiliation.owner.getValue());
++            try (final ResultSet rs = pstmt.executeQuery()) {
++                while (rs.next()) {
++                    final long roomID = rs.getLong(1);
++                    final String storedJID = rs.getString(2);
++                    hasOwner.merge(roomID, resolveToAccountOtherThan(storedJID, null) != null, Boolean::logicalOr);
++                    if (storedJID != null && (storedJID.equals(groupJID.toString()) || storedJID.equals(groupJID.toBareJID()))) {
++                        ownedByGroup.add(roomID);
++                    }
++                }
++            }
++        }
++        final List<Long> result = new ArrayList<>();
++        for (final Long roomID : ownedByGroup) {
++            if (!Boolean.TRUE.equals(hasOwner.get(roomID))) {
++                result.add(roomID);
++            }
++        }
++        return result;
++    }
++
+     /**
+      * Saves the conversation log entry batch to the database.
+      *
+diff --git a/xmppserver/src/test/java/org/jivesoftware/openfire/muc/UserDeletionOwnershipTest.java b/xmppserver/src/test/java/org/jivesoftware/openfire/muc/UserDeletionOwnershipTest.java
+new file mode 100644
+index 0000000..e9c3a49
+--- /dev/null
++++ b/xmppserver/src/test/java/org/jivesoftware/openfire/muc/UserDeletionOwnershipTest.java
+@@ -0,0 +1,655 @@
++package org.jivesoftware.openfire.muc;
++
++import org.jivesoftware.Fixtures;
++import org.jivesoftware.database.DbConnectionManager;
++import org.jivesoftware.database.DefaultConnectionProvider;
++import org.jivesoftware.openfire.XMPPServer;
++import org.jivesoftware.openfire.event.GroupEventDispatcher;
++import org.jivesoftware.openfire.event.UserEventDispatcher;
++import org.jivesoftware.openfire.group.Group;
++import org.jivesoftware.openfire.group.GroupJID;
++import org.jivesoftware.openfire.group.GroupManager;
++import org.jivesoftware.openfire.group.GroupNotFoundException;
++import org.jivesoftware.openfire.muc.spi.MUCPersistenceManager;
++import org.jivesoftware.openfire.muc.spi.MultiUserChatServiceImpl;
++import org.jivesoftware.openfire.user.User;
++import org.jivesoftware.util.cache.CacheFactory;
++import org.junit.jupiter.api.AfterEach;
++import org.junit.jupiter.api.BeforeAll;
++import org.junit.jupiter.api.BeforeEach;
++import org.junit.jupiter.api.Test;
++import org.xmpp.component.ComponentManager;
++import org.xmpp.component.ComponentManagerFactory;
++import org.xmpp.packet.JID;
++
++import java.nio.file.Files;
++import java.nio.file.Path;
++import java.sql.Connection;
++import java.sql.PreparedStatement;
++import java.sql.ResultSet;
++import java.util.ArrayList;
++import java.util.Arrays;
++import java.util.Collections;
++import java.util.List;
++import java.util.Map;
++import java.util.concurrent.locks.ReentrantLock;
++
++import static org.junit.jupiter.api.Assertions.assertEquals;
++import static org.junit.jupiter.api.Assertions.assertFalse;
++import static org.junit.jupiter.api.Assertions.assertNotNull;
++import static org.junit.jupiter.api.Assertions.assertTrue;
++import static org.mockito.ArgumentMatchers.anyString;
++import static org.mockito.Mockito.doAnswer;
++import static org.mockito.Mockito.doReturn;
++import static org.mockito.Mockito.mock;
++import static org.mockito.Mockito.withSettings;
++
++/**
++ * Tests that verify that deleting a user account does not leave a chat room without anyone that can administer it,
++ * and does not leave the deleted account in charge of anything (OF-2166).
++ *
++ * Each test drives the event listeners for the "user is being deleted" event that the affected component registers,
++ * and then observes the database (and, where the room is in memory, the room itself).
++ */
++public class UserDeletionOwnershipTest {
++
++    static final String DRIVER = "org.hsqldb.jdbcDriver";
++    static String URL;
++    static Path dbDir;
++    static final String DOMAIN = Fixtures.XMPP_DOMAIN;
++    static final String ALICE = "alice@" + DOMAIN;
++    static final String BOB = "bob@" + DOMAIN;
++    static final String CAROL = "carol@" + DOMAIN;
++    static final String DAVE = "dave@" + DOMAIN;
++    static final String ROOT = "root@" + DOMAIN;
++    static final String ADMIN = "admin@" + DOMAIN;
++
++    XMPPServer xmppServer;
++    MultiUserChatManager mucManagerMock;
++    MultiUserChatService serviceMock;
++    final List<JID> admins = new ArrayList<>();
++
++    @BeforeAll
++    static void initDb() throws Exception {
++        Fixtures.reconfigureOpenfireHome();
++        final Path src = Path.of(UserDeletionOwnershipTest.class.getResource("/datasets/openfire.script").toURI()).getParent();
++        dbDir = Files.createTempDirectory("ofuserdel");
++        Files.copy(src.resolve("openfire.script"), dbDir.resolve("openfire.script"));
++        Files.copy(src.resolve("openfire.properties"), dbDir.resolve("openfire.properties"));
++        URL = "jdbc:hsqldb:" + dbDir.resolve("openfire") + ";ifexists=true";
++    }
++
++    @BeforeEach
++    void setUp() throws Exception {
++        CacheFactory.initialize();
++        Fixtures.clearExistingProperties();
++        Arrays.stream(CacheFactory.getAllCaches()).forEach(Map::clear);
++
++        final DefaultConnectionProvider cp = new DefaultConnectionProvider();
++        cp.setDriver(DRIVER);
++        cp.setServerURL(URL);
++        cp.setUsername("sa");
++        cp.setPassword("");
++        DbConnectionManager.setConnectionProvider(cp);
++        MultiUserChatManager.MASTER_KEY.setValue("user-deletion-test-master-key");
++
++        admins.clear();
++        xmppServer = Fixtures.mockXMPPServer();
++        mucManagerMock = mock(MultiUserChatManager.class, withSettings().lenient());
++        doReturn(1L).when(mucManagerMock).getMultiUserChatServiceID(anyString());
++        doReturn(mucManagerMock).when(xmppServer).getMultiUserChatManager();
++        doAnswer(i -> admins).when(xmppServer).getAdmins();
++        XMPPServer.setInstance(xmppServer);
++
++        serviceMock = mock(MultiUserChatService.class, withSettings().lenient());
++        doReturn("conference").when(serviceMock).getServiceName();
++        doReturn("conference." + DOMAIN).when(serviceMock).getServiceDomain();
++        doReturn(new HistoryStrategy()).when(serviceMock).getHistoryStrategy();
++        doAnswer(i -> new ReentrantLock()).when(serviceMock).getChatRoomLock(anyString());
++
++        for (final String table : new String[]{"ofMucAffiliation", "ofMucMember", "ofMucRoom",
++                "ofMucServiceProp", "ofMucService", "ofGroupUser", "ofGroupProp", "ofGroup"}) {
++            sql("DELETE FROM " + table);
++        }
++        // A service's settings are cached per subdomain for the life of the JVM, and the rows were just deleted
++        // underneath that cache.
++        MUCPersistenceManager.refreshProperties("conference");
++    }
++
++    MultiUserChatManager startedManager;
++    MultiUserChatServiceImpl startedService;
++
++    @AfterEach
++    void tearDown() {
++        // A service that was never started as a component has little to shut down, and parts of the server it would
++        // talk to are not there in a unit test: each step is attempted on its own, so that one of them failing does
++        // not leave the next test holding this test's manager and service.
++        if (startedService != null) {
++            try {
++                for (final MUCRoom room : startedService.getActiveChatRooms()) {
++                    UserEventDispatcher.removeListener(room);
++                    GroupEventDispatcher.removeListener(room);
++                }
++            } catch (Exception ignored) { }
++        }
++        if (startedManager != null) {
++            try { startedManager.stop(); } catch (Exception ignored) { }
++            try { startedManager.unregisterMultiUserChatService("conference", false); } catch (Exception ignored) { }
++        }
++        if (startedService != null) {
++            try { startedService.shutdown(); } catch (Exception ignored) { }
++        }
++        startedManager = null;
++        startedService = null;
++        Arrays.stream(CacheFactory.getAllCaches()).forEach(Map::clear);
++    }
++
++    /**
++     * The chat service as the server runs it: its row in the database, and a chat manager that is initialized and
++     * started the way the server starts it. The group manager is created first, as it is at boot, so that its own
++     * listener for deleted accounts (which takes an account out of its groups) runs before the chat manager's.
++     */
++    MultiUserChatServiceImpl startedService() throws Exception {
++        if (startedService != null) {
++            return startedService;
++        }
++        GroupManager.getInstance();
++        ComponentManagerFactory.setComponentManager(mock(ComponentManager.class, withSettings().lenient()));
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "INSERT INTO ofMucService (serviceID,subdomain,description,isHidden) VALUES (1,'conference',NULL,0)")) {
++            p.executeUpdate();
++        }
++        MUCPersistenceManager.refreshProperties("conference");
++        startedManager = new MultiUserChatManager();
++        doReturn(startedManager).when(xmppServer).getMultiUserChatManager();
++        startedManager.initialize(xmppServer);
++        startedManager.start();
++        startedService = (MultiUserChatServiceImpl) startedManager.getMultiUserChatService("conference");
++        return startedService;
++    }
++
++    /** UserManager.deleteUser: one dispatch, heard by every listener that registered for it. */
++    void deleteAccount(String username) throws Exception {
++        startedService();
++        UserEventDispatcher.dispatchEvent(mockUser(username),
++            UserEventDispatcher.EventType.user_deleting, Collections.emptyMap());
++    }
++
++    // ─── fixture helpers ────────────────────────────────────────────────────
++
++    static void sql(String statement) throws Exception {
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(statement)) {
++            p.executeUpdate();
++        }
++    }
++
++    void createPersistentRoom(long roomId, String name) throws Exception {
++        String now = String.valueOf(System.currentTimeMillis());
++        while (now.length() < 15) now = "0" + now;
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "INSERT INTO ofMucRoom (serviceID,roomID,creationDate,modificationDate,name,naturalName," +
++                 "description,lockedDate,emptyDate,canChangeSubject,maxUsers,publicRoom,moderated,membersOnly," +
++                 "canInvite,roomPassword,canDiscoverJID,logEnabled,retireOnDeletion,preserveHistOnDel,subject," +
++                 "rolesToBroadcast,useReservedNick,canChangeNick,canRegister,allowpm) " +
++                 "VALUES (1,?,?,?,?,?,NULL,?,?,1,30,1,0,0,0,NULL,1,1,0,1,NULL,7,0,1,1,0)")) {
++            p.setLong(1, roomId); p.setString(2, now); p.setString(3, now);
++            p.setString(4, name); p.setString(5, name); p.setString(6, now); p.setString(7, now);
++            p.executeUpdate();
++        }
++    }
++
++    void addAffiliation(long roomId, String bareJid, Affiliation affiliation) throws Exception {
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "INSERT INTO ofMucAffiliation (roomID,jid,affiliation) VALUES (?,?,?)")) {
++            p.setLong(1, roomId); p.setString(2, bareJid); p.setInt(3, affiliation.getValue());
++            p.executeUpdate();
++        }
++    }
++
++    void addMember(long roomId, String bareJid, String nickname) throws Exception {
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "INSERT INTO ofMucMember (roomID,jid,nickname) VALUES (?,?,?)")) {
++            p.setLong(1, roomId); p.setString(2, bareJid); p.setString(3, nickname);
++            p.executeUpdate();
++        }
++    }
++
++    List<String> affiliationRows(long roomId) throws Exception {
++        final List<String> out = new ArrayList<>();
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "SELECT jid,affiliation FROM ofMucAffiliation WHERE roomID=? ORDER BY jid,affiliation")) {
++            p.setLong(1, roomId);
++            try (ResultSet rs = p.executeQuery()) {
++                while (rs.next()) out.add(rs.getString(1) + ":" + rs.getInt(2));
++            }
++        }
++        return out;
++    }
++
++    List<String> ownerRows(long roomId) throws Exception {
++        final List<String> out = new ArrayList<>();
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "SELECT jid FROM ofMucAffiliation WHERE roomID=? AND affiliation=? ORDER BY jid")) {
++            p.setLong(1, roomId); p.setInt(2, Affiliation.owner.getValue());
++            try (ResultSet rs = p.executeQuery()) {
++                while (rs.next()) out.add(rs.getString(1));
++            }
++        }
++        return out;
++    }
++
++    List<String> memberRows(long roomId) throws Exception {
++        final List<String> out = new ArrayList<>();
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "SELECT jid,nickname FROM ofMucMember WHERE roomID=? ORDER BY jid")) {
++            p.setLong(1, roomId);
++            try (ResultSet rs = p.executeQuery()) {
++                while (rs.next()) out.add(rs.getString(1) + ":" + rs.getString(2));
++            }
++        }
++        return out;
++    }
++
++    List<String> rawServiceProperty(String name) throws Exception {
++        final List<String> out = new ArrayList<>();
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "SELECT propValue FROM ofMucServiceProp WHERE name=? ORDER BY propValue")) {
++            p.setString(1, name);
++            try (ResultSet rs = p.executeQuery()) {
++                while (rs.next()) out.add(rs.getString(1));
++            }
++        }
++        return out;
++    }
++
++    static User mockUser(String username) {
++        final User u = mock(User.class, withSettings().lenient());
++        doReturn(username).when(u).getUsername();
++        return u;
++    }
++
++    /** The dispatch of UserManager.deleteUser that reaches the rooms that are not in memory. */
++    static void fireDatabasePathListener(String username) {
++        new MultiUserChatManager().userDeleting(mockUser(username), Collections.emptyMap());
++    }
++
++    MUCRoom loadRoom(String name) {
++        final MUCRoom room = new MUCRoom(serviceMock, name);
++        MUCPersistenceManager.loadFromDB(room);
++        return room;
++    }
++
++    /**
++     * Resolves a stored affiliation entry to an existing account other than the one named. An entry that refers to a
++     * shared group resolves to a member of that group. Any account will do: what is checked is that SOMEBODY is left
++     * who can run the room, never who in particular.
++     */
++    static String resolveToAccountOtherThan(String storedJid, String excluded) {
++        if (storedJid == null || storedJid.isEmpty()) {
++            return null;
++        }
++        final JID stored = new JID(storedJid);
++        if (GroupJID.isGroup(stored)) {
++            try {
++                final Group group = GroupManager.getInstance().getGroup(stored);
++                for (final JID member : group.getAll()) {
++                    if (!member.asBareJID().toString().equals(excluded)) {
++                        return member.asBareJID().toString();
++                    }
++                }
++            } catch (GroupNotFoundException e) {
++                return null;
++            }
++            return null;
++        }
++        return stored.asBareJID().toString().equals(excluded) ? null : stored.asBareJID().toString();
++    }
++
++    static String someoneWhoCanRun(List<String> ownerEntries, String excluded) {
++        for (final String entry : ownerEntries) {
++            final String resolved = resolveToAccountOtherThan(entry, excluded);
++            if (resolved != null) {
++                return resolved;
++            }
++        }
++        return null;
++    }
++
++    static List<String> asStrings(Iterable<JID> jids) {
++        final List<String> out = new ArrayList<>();
++        for (final JID jid : jids) {
++            out.add(jid.toString());
++        }
++        return out;
++    }
++
++    // ─── tests ──────────────────────────────────────────────────────────────
++
++    /**
++     * The membership of a room, as it has to come out of a deletion. Every row that went in is still there, with two
++     * exceptions that the ticket itself makes: the row of the account that is leaving, and the row of whoever had to
++     * take the room over - promoting a member is how the product hands a room on, and it drops that membership when it
++     * does (MUCRoom#addOwner). Nothing else may appear, disappear or change. Who was promoted is the change's call, so
++     * this subtracts whoever owns the room now instead of naming anybody.
++     */
++    void assertMembershipSurvived(long roomId, List<String> wentIn, String deleted) throws Exception {
++        final List<String> cameOut = memberRows(roomId);
++        final List<String> owners = ownerRows(roomId);
++        for (final String row : cameOut) {
++            assertTrue(wentIn.contains(row),
++                "room " + roomId + ": a membership that was not there came out of the deletion: went in=" + wentIn
++                + " came out=" + cameOut);
++        }
++        for (final String row : wentIn) {
++            if (cameOut.contains(row)) {
++                continue;
++            }
++            final String jid = row.substring(0, row.indexOf(':'));
++            if (jid.equals(deleted)) {
++                continue;
++            }
++            assertTrue(owners.contains(jid),
++                "room " + roomId + ": '" + jid + "' stopped being a member of a room it did not take over: went in="
++                + wentIn + " came out=" + cameOut + " owners=" + owners);
++        }
++    }
++
++    @Test
++    public void db_path_persistent_room_keeps_an_owner() throws Exception {
++        createPersistentRoom(101, "keepsanowner");
++        addAffiliation(101, ALICE, Affiliation.owner);
++        addMember(101, CAROL, "caro");
++        admins.add(new JID(ADMIN));
++
++        fireDatabasePathListener("alice");
++
++        final List<String> owners = ownerRows(101);
++        assertNotNull(someoneWhoCanRun(owners, ALICE),
++            "The room is left without an owner that refers to an existing account: " + affiliationRows(101));
++        assertFalse(affiliationRows(101).stream().anyMatch(r -> r.startsWith(ALICE + ":")),
++            "The deleted account is still affiliated with the room: " + affiliationRows(101));
++        assertFalse(memberRows(101).stream().anyMatch(r -> r.startsWith(ALICE + ":")),
++            "The deleted account still belongs to the room: " + memberRows(101));
++
++        final MUCRoom room = loadRoom("keepsanowner");
++        assertFalse(room.getOwners().isEmpty(), "The reloaded room has no owner at all.");
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The reloaded room still gives the deleted account an affiliation.");
++    }
++
++    @Test
++    public void db_path_promotion_when_the_admin_already_has_a_row() throws Exception {
++        createPersistentRoom(102, "adminhasarow");
++        addAffiliation(102, ALICE, Affiliation.owner);
++        addAffiliation(102, ADMIN, Affiliation.outcast);
++        admins.add(new JID(ADMIN));
++
++        fireDatabasePathListener("alice");
++
++        final List<String> rows = affiliationRows(102);
++        assertNotNull(someoneWhoCanRun(ownerRows(102), ALICE),
++            "The room is left without an owner that refers to an existing account: " + rows);
++        assertFalse(rows.stream().anyMatch(r -> r.startsWith(ALICE + ":")),
++            "The deleted account is still affiliated with the room: " + rows);
++
++        final MUCRoom room = loadRoom("adminhasarow");
++        assertFalse(room.getOwners().isEmpty(), "The reloaded room has no owner at all.");
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The reloaded room still gives the deleted account an affiliation.");
++    }
++
++    @Test
++    public void promotion_when_the_server_has_no_admin_accounts() throws Exception {
++        createPersistentRoom(103, "noadmins");
++        final MUCRoom room = new MUCRoom(serviceMock, "noadmins");
++        room.setID(103); room.setPersistent(true); room.setSavedToDB(true);
++        room.addOwner(new JID(ALICE), Affiliation.owner);
++        room.addAdmin(new JID(BOB), Affiliation.owner);
++        room.addMember(new JID(CAROL), "caro", Affiliation.owner);
++        admins.clear();
++
++        room.userDeleting(mockUser("alice"), Collections.emptyMap());
++
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The deleted account still has an affiliation with the room: owners=" + asStrings(room.getOwners()));
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), ALICE),
++            "The room is left without an owner that refers to an existing account: " + asStrings(room.getOwners()));
++    }
++
++    @Test
++    public void promotion_when_the_only_admin_is_the_deleted_user() throws Exception {
++        createPersistentRoom(113, "adminisdeleted");
++        final MUCRoom room = new MUCRoom(serviceMock, "adminisdeleted");
++        room.setID(113); room.setPersistent(true); room.setSavedToDB(true);
++        room.addOwner(new JID(ALICE), Affiliation.owner);
++        room.addAdmin(new JID(BOB), Affiliation.owner);
++        admins.clear();
++        admins.add(new JID(ALICE));
++
++        room.userDeleting(mockUser("alice"), Collections.emptyMap());
++
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The deleted account still has an affiliation with the room: owners=" + asStrings(room.getOwners()));
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), ALICE),
++            "The room is left without an owner that refers to an existing account: " + asStrings(room.getOwners()));
++    }
++
++    @Test
++    public void service_level_lists_release_the_deleted_user() throws Exception {
++        ComponentManagerFactory.setComponentManager(mock(ComponentManager.class, withSettings().lenient()));
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "INSERT INTO ofMucService (serviceID,subdomain,description,isHidden) VALUES (1,'conference',NULL,0)")) {
++            p.executeUpdate();
++        }
++
++        final MultiUserChatManager manager = new MultiUserChatManager();
++        doReturn(manager).when(xmppServer).getMultiUserChatManager();
++        final MultiUserChatServiceImpl service = new MultiUserChatServiceImpl(1L, "conference", null, false);
++        manager.registerMultiUserChatService(service, false);
++
++        MUCPersistenceManager.setProperty("conference", "sysadmin.jid", ALICE + "," + ROOT);
++        MUCPersistenceManager.setProperty("conference", "create.jid", ALICE + "," + DAVE);
++        service.initializeSettings();
++        assertTrue(service.isSysadmin(new JID(ALICE)), "fixture: the account is not a sysadmin to begin with");
++
++        // Dispatched the way the server dispatches it, so that a change that hangs its own listener
++        // off this event is seen exactly like a change that extends the one that is already there.
++        UserEventDispatcher.addListener(manager);
++        try {
++            UserEventDispatcher.dispatchEvent(mockUser("alice"),
++                UserEventDispatcher.EventType.user_deleting, Collections.emptyMap());
++        } finally {
++            UserEventDispatcher.removeListener(manager);
++        }
++
++        final List<String> sysadmins = rawServiceProperty("sysadmin.jid");
++        final List<String> creators = rawServiceProperty("create.jid");
++        assertFalse(sysadmins.toString().contains(ALICE),
++            "The deleted account still administers the chat service: sysadmin.jid=" + sysadmins);
++        assertFalse(creators.toString().contains(ALICE),
++            "The deleted account may still create rooms on the chat service: create.jid=" + creators);
++        assertTrue(sysadmins.toString().contains(ROOT),
++            "The other administrator of the chat service was dropped as well: sysadmin.jid=" + sysadmins);
++        assertTrue(creators.toString().contains(DAVE),
++            "The other account allowed to create rooms was dropped as well: create.jid=" + creators);
++        assertFalse(service.isSysadmin(new JID(ALICE)),
++            "The running service still treats the deleted account as its administrator.");
++    }
++
++    @Test
++    public void group_owned_room_out_of_memory_keeps_an_owner() throws Exception {
++        final GroupManager groupManager = GroupManager.getInstance();
++        final Group group = groupManager.createGroup("roomowners");
++        group.getMembers().add(new JID(ALICE));
++        final String groupJid = new GroupJID("roomowners").toString();
++
++        createPersistentRoom(107, "groupownedoutofmemory");
++        addAffiliation(107, groupJid, Affiliation.owner);
++        admins.add(new JID(ADMIN));
++
++        groupManager.deleteUser(mockUser("alice"));
++        fireDatabasePathListener("alice");
++
++        assertNotNull(someoneWhoCanRun(ownerRows(107), ALICE),
++            "The room is left without an owner that refers to an existing account: " + affiliationRows(107));
++    }
++
++    @Test
++    public void group_owned_room_in_memory_keeps_an_owner() throws Exception {
++        final GroupManager groupManager = GroupManager.getInstance();
++        final Group group = groupManager.createGroup("roomowners2");
++        group.getMembers().add(new JID(ALICE));
++        final String groupJid = new GroupJID("roomowners2").toString();
++
++        createPersistentRoom(207, "groupownedinmemory");
++        addAffiliation(207, groupJid, Affiliation.owner);
++        admins.add(new JID(ADMIN));
++
++        final MUCRoom room = loadRoom("groupownedinmemory");
++        assertEquals(Affiliation.owner, room.getAffiliation(new JID(ALICE)),
++            "fixture: the account does not own the room through the group to begin with");
++
++        groupManager.deleteUser(mockUser("alice"));
++        room.userDeleting(mockUser("alice"), Collections.emptyMap());
++
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), ALICE),
++            "The room is left without an owner that refers to an existing account: " + asStrings(room.getOwners()));
++    }
++
++    @Test
++    public void rooms_that_keep_another_owner_come_out_unchanged() throws Exception {
++        createPersistentRoom(301, "soleowner");
++        addAffiliation(301, ALICE, Affiliation.owner);
++
++        createPersistentRoom(302, "onlyamember");
++        addAffiliation(302, BOB, Affiliation.owner);
++        addMember(302, ALICE, "ali");
++        addMember(302, CAROL, "caro");
++
++        createPersistentRoom(303, "twoowners");
++        addAffiliation(303, ALICE, Affiliation.owner);
++        addAffiliation(303, BOB, Affiliation.owner);
++
++        createPersistentRoom(304, "soleownerwithmembers");
++        addAffiliation(304, ALICE, Affiliation.owner);
++        addMember(304, CAROL, "caro");
++        addMember(304, DAVE, "dav");
++
++        admins.add(new JID(ADMIN));
++
++        fireDatabasePathListener("alice");
++
++        assertNotNull(someoneWhoCanRun(ownerRows(301), ALICE),
++            "The room that lost its only owner is left without one: " + affiliationRows(301));
++        assertEquals(List.of(BOB + ":" + Affiliation.owner.getValue()), affiliationRows(302),
++            "A room that kept its owner did not come out unchanged.");
++        assertEquals(List.of(CAROL + ":caro"), memberRows(302),
++            "A room that kept its owner did not come out unchanged.");
++        assertEquals(List.of(BOB + ":" + Affiliation.owner.getValue()), affiliationRows(303),
++            "A room that kept one of its two owners did not come out unchanged.");
++        assertNotNull(someoneWhoCanRun(ownerRows(304), ALICE),
++            "The room that lost its only owner is left without one: " + affiliationRows(304));
++        assertMembershipSurvived(304, List.of(CAROL + ":caro", DAVE + ":dav"), ALICE);
++    }
++
++    @Test
++    public void in_memory_room_with_no_admin_accounts_is_taken_over_by_a_member() throws Exception {
++        createPersistentRoom(103, "onlymembersleft");
++        addAffiliation(103, ALICE, Affiliation.owner);
++        addMember(103, CAROL, "caro");
++        admins.clear();
++        final MUCRoom room = startedService().getChatRoom("onlymembersleft");
++        assertNotNull(room, "fixture: the room did not load");
++
++        deleteAccount("alice");
++
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The deleted account still has an affiliation with the room.");
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), ALICE),
++            "The room is left without an owner: " + asStrings(room.getOwners()));
++        assertNotNull(someoneWhoCanRun(ownerRows(103), ALICE),
++            "After a restart the room has no owner: " + affiliationRows(103));
++    }
++
++    @Test
++    public void db_path_room_is_taken_over_when_the_only_admin_is_the_one_leaving() throws Exception {
++        createPersistentRoom(113, "onlyadminleaves");
++        addAffiliation(113, ALICE, Affiliation.owner);
++        addMember(113, CAROL, "caro");
++        admins.clear();
++        admins.add(new JID(ALICE));
++
++        deleteAccount("alice");
++
++        assertNotNull(someoneWhoCanRun(ownerRows(113), ALICE),
++            "The room is left without an owner: " + affiliationRows(113));
++        assertFalse(affiliationRows(113).stream().anyMatch(r -> r.startsWith(ALICE + ":")),
++            "The deleted account is still affiliated with the room: " + affiliationRows(113));
++    }
++
++    @Test
++    public void group_emptied_by_a_removal_keeps_its_room_owned_out_of_memory() throws Exception {
++        startedService();
++        final GroupManager groupManager = GroupManager.getInstance();
++        groupManager.createGroup("removedowners").getMembers().add(new JID(ALICE));
++        createPersistentRoom(108, "groupemptiedoutofmemory");
++        addAffiliation(108, new GroupJID("removedowners").toString(), Affiliation.owner);
++        addMember(108, CAROL, "caro");
++        admins.add(new JID(ADMIN));
++
++        groupManager.getGroup("removedowners").getMembers().remove(new JID(ALICE));
++
++        assertNotNull(someoneWhoCanRun(ownerRows(108), null),
++            "The room still names only a group that has nobody in it: " + affiliationRows(108));
++    }
++
++    @Test
++    public void group_emptied_by_a_removal_keeps_its_room_owned_in_memory() throws Exception {
++        final MultiUserChatServiceImpl service = startedService();
++        final GroupManager groupManager = GroupManager.getInstance();
++        groupManager.createGroup("removedowners2").getMembers().add(new JID(ALICE));
++        createPersistentRoom(208, "groupemptiedinmemory");
++        addAffiliation(208, new GroupJID("removedowners2").toString(), Affiliation.owner);
++        addMember(208, CAROL, "caro");
++        admins.add(new JID(ADMIN));
++        final MUCRoom room = service.getChatRoom("groupemptiedinmemory");
++        assertNotNull(room, "fixture: the room did not load");
++
++        groupManager.getGroup("removedowners2").getMembers().remove(new JID(ALICE));
++
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), null),
++            "The room still names only a group that has nobody in it: " + asStrings(room.getOwners()));
++        assertNotNull(someoneWhoCanRun(ownerRows(208), null),
++            "After a restart the room names only a group that has nobody in it: " + affiliationRows(208));
++    }
++
++    @Test
++    public void in_memory_promotion_when_the_admin_is_banned_from_the_room() throws Exception {
++        createPersistentRoom(116, "adminisbanned");
++        addAffiliation(116, ALICE, Affiliation.owner);
++        addAffiliation(116, ADMIN, Affiliation.outcast);
++        admins.add(new JID(ALICE));
++        admins.add(new JID(ADMIN));
++        final MUCRoom room = startedService().getChatRoom("adminisbanned");
++        assertNotNull(room, "fixture: the room did not load");
++
++        deleteAccount("alice");
++
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The deleted account still has an affiliation with the room.");
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), ALICE),
++            "The room is left without an owner: " + asStrings(room.getOwners()));
++        assertNotNull(someoneWhoCanRun(ownerRows(116), ALICE),
++            "After a restart the room has no owner: " + affiliationRows(116));
++    }
++}

harbor/tasks/openfire_userdeleting_last_owner_contract/solution/solve.sh

@@ -0,0 +1,1310 @@
+#!/bin/bash
+set -eu
+cd /workspace/repo
+git apply <<'REFERENCE_PATCH'
+diff --git a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MUCRoom.java b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MUCRoom.java
+index b569890..043dc8d 100644
+--- a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MUCRoom.java
++++ b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MUCRoom.java
+@@ -4120,7 +4120,9 @@ public class MUCRoom implements GroupEventListener, UserEventListener, Externali
+ 
+     @Override
+     public void memberRemoved(Group group, Map<String, ?> params) {
+-        applyAffiliationChangeAndSendPresence(new JID((String)params.get("member")));
++        final JID member = new JID((String)params.get("member"));
++        applyAffiliationChangeAndSendPresence(member);
++        keepAnOwnerAfterGroupChange(group, member);
+     }
+ 
+     @Override
+@@ -4130,7 +4132,44 @@ public class MUCRoom implements GroupEventListener, UserEventListener, Externali
+ 
+     @Override
+     public void adminRemoved(Group group, Map<String, ?> params) {
+-        applyAffiliationChangeAndSendPresence(new JID((String)params.get("admin")));
++        final JID admin = new JID((String)params.get("admin"));
++        applyAffiliationChangeAndSendPresence(admin);
++        keepAnOwnerAfterGroupChange(group, admin);
++    }
++
++    /**
++     * A shared group can own this room. When the last person is taken out of such a group, nobody is left who can
++     * administer the room - the same state that deleting its last owner leaves behind - so the room is given a new owner
++     * here. Rooms that are not in memory are seen to by MultiUserChatManager.
++     *
++     * @param group The group that somebody was taken out of.
++     * @param removed The address that was taken out of the group. It is not handed the room: it was just taken out of
++     *                the group that owned it.
++     */
++    private void keepAnOwnerAfterGroupChange(@Nonnull final Group group, @Nullable final JID removed)
++    {
++        if (!owners.contains(group.getJID())) {
++            return;
++        }
++        final Lock lock = getMUCService().getChatRoomLock(getJID().getNode());
++        lock.lock();
++        try {
++            if (hasOwnerOtherThan(null)) {
++                return;
++            }
++            final JID replacementJid = findReplacementOwner(removed);
++            if (replacementJid == null) {
++                Log.warn("The last person was taken out of group '{}', which owns MUC room '{}', but no account could be found to take over ownership of the room.", group.getName(), getJID());
++                return;
++            }
++            Log.info("The last person was taken out of group '{}', which owns MUC room '{}'. To prevent having a room without owner, '{}' was made owner of the room.", group.getName(), getJID(), replacementJid);
++            addOwner(replacementJid, getSelfRepresentation().getAffiliation());
++            getMUCService().syncChatRoom(this);
++        } catch (Throwable t) {
++            Log.warn("A problem occurred while trying to keep an owner for room '{}' after group '{}' lost a member.", getJID(), group.getName(), t);
++        } finally {
++            lock.unlock();
++        }
+     }
+ 
+     private void applyAffiliationChangeAndSendPresence(JID groupMember) {
+@@ -4161,21 +4200,33 @@ public class MUCRoom implements GroupEventListener, UserEventListener, Externali
+         try {
+             lock.lock();
+ 
+-            if (getAffiliation(userJid) == Affiliation.none) {
+-                // User had no affiliation with this room.
+-                return;
++            final boolean wasAffiliated = getAffiliation(userJid) != Affiliation.none;
++
++            // Cannot remove the last owner of a chat room. To prevent issues, replace the owner with an administrative
++            // account. Note that ownership can be held through a shared group, in which case this room loses its last
++            // owner when that group loses its last member - which is the same event, reaching this room through a user
++            // that this room does not list at all.
++            boolean roomChanged = false;
++            if (isLeftWithoutOwnerBy(userJid)) {
++                final JID replacementJid = findReplacementOwner(userJid);
++                if (replacementJid == null) {
++                    Log.warn("User '{}' is being deleted, and is the last owner of MUC room '{}', but no account could be found to take over ownership of the room.", user.getUsername(), getJID());
++                } else {
++                    Log.info("User '{}' is being deleted, but is also the only owner of MUC room '{}'. To prevent having a room without owner, '{}' was made owner of the room.", user.getUsername(), getJID(), replacementJid);
++                    addOwner(replacementJid, getSelfRepresentation().getAffiliation());
++                    roomChanged = true;
++                }
+             }
+ 
+-            // Cannot remove the last owner of a chat room. To prevent issues, replace the owner with an administrative account.
+-            if (getOwners().contains(userJid) && getOwners().size() == 1) {
+-                final JID adminJid = XMPPServer.getInstance().getAdmins().iterator().next();
+-                Log.info("User '{}' is being deleted, but is also the only owner of MUC room '{}'. To prevent having a room without owner, server admin '{}' was made owner of the room.", user.getUsername(), getJID(), adminJid);
+-                addOwner(adminJid, getSelfRepresentation().getAffiliation());
++            if (wasAffiliated) {
++                // Remove the affiliation of the deleted user with the room
++                addNone(userJid, getSelfRepresentation().getAffiliation());
++                roomChanged = true;
+             }
+ 
+-            // Remove the affiliation of the deleted user with the room
+-            addNone(userJid, getSelfRepresentation().getAffiliation());
+-            getMUCService().syncChatRoom(this);
++            if (roomChanged) {
++                getMUCService().syncChatRoom(this);
++            }
+         } catch (Throwable t) {
+             Log.warn("A problem occurred while trying to update room '{}' as a result of user '{}' being deleted from Openfire.", getJID(), user);
+         } finally {
+@@ -4183,6 +4234,107 @@ public class MUCRoom implements GroupEventListener, UserEventListener, Externali
+         }
+     }
+ 
++    /**
++     * Checks if the removal of the provided address leaves this room without an owner that stands for an existing
++     * account.
++     *
++     * A room whose owner entries never stood for the address that is going, and could not have been emptied by its
++     * departure either, is not left without an owner by this deletion: whatever state it is in, it was in before, and
++     * giving it a new owner here would change a room that this deletion did not touch. An owner entry that names a
++     * shared group that no longer exists is such a case - deleting a user does not delete groups.
++     *
++     * @param excludedAddress The (real) JID that is going.
++     * @return true if this room is about to be left without anyone that can administer it, otherwise false.
++     */
++    private boolean isLeftWithoutOwnerBy(@Nonnull final JID excludedAddress)
++    {
++        if (hasOwnerOtherThan(excludedAddress)) {
++            return false;
++        }
++        final JID excluded = excludedAddress.asBareJID();
++        for (final JID owner : owners) {
++            if (GroupJID.isGroup(owner)) {
++                try {
++                    GroupManager.getInstance().getGroup(owner);
++                    return true;
++                } catch (GroupNotFoundException e) {
++                    Log.debug("Room '{}' is owned by group '{}', which no longer exists.", getJID(), owner, e);
++                }
++            } else if (excluded.equals(owner.asBareJID())) {
++                return true;
++            }
++        }
++        return false;
++    }
++
++    /**
++     * Checks if this room has an owner other than the provided address. An owner that is held through a shared group
++     * counts only when that group still has a member other than the provided address: a group without members leaves
++     * the room without anyone that can administer it, exactly like an empty list of owners does.
++     *
++     * @param excludedAddress The (real) JID that is not to be taken into account, or null to count every owner.
++     * @return true if another account owns this room, otherwise false.
++     */
++    private boolean hasOwnerOtherThan(@Nullable final JID excludedAddress)
++    {
++        final JID excluded = excludedAddress == null ? null : excludedAddress.asBareJID();
++        for (final JID owner : owners) {
++            if (GroupJID.isGroup(owner)) {
++                try {
++                    for (final JID groupMember : GroupManager.getInstance().getGroup(owner).getAll()) {
++                        if (!groupMember.asBareJID().equals(excluded)) {
++                            return true;
++                        }
++                    }
++                } catch (GroupNotFoundException e) {
++                    Log.debug("Room '{}' is owned by group '{}', which no longer exists.", getJID(), owner, e);
++                }
++            } else if (!owner.asBareJID().equals(excluded)) {
++                return true;
++            }
++        }
++        return false;
++    }
++
++    /**
++     * Finds an account that can take over ownership of this room: a server administrator when there is one, and
++     * otherwise someone that this room already trusts.
++     *
++     * @param excludedAddress The (real) JID that is not to be selected (typically: a user that is being deleted), or null.
++     * @return the address of the new owner, or null when no suitable account exists.
++     */
++    @Nullable
++    private JID findReplacementOwner(@Nullable final JID excludedAddress)
++    {
++        final List<Collection<JID>> candidateLists = new ArrayList<>();
++        candidateLists.add(XMPPServer.getInstance().getAdmins());
++        candidateLists.add(new ArrayList<>(admins));
++        candidateLists.add(getMembers());
++
++        final JID excluded = excludedAddress == null ? null : excludedAddress.asBareJID();
++        for (final Collection<JID> candidates : candidateLists) {
++            for (final JID candidate : candidates) {
++                if (candidate == null) {
++                    continue;
++                }
++                if (GroupJID.isGroup(candidate)) {
++                    try {
++                        for (final JID groupMember : GroupManager.getInstance().getGroup(candidate).getAll()) {
++                            if (!groupMember.asBareJID().equals(excluded)) {
++                                return groupMember.asBareJID();
++                            }
++                        }
++                    } catch (GroupNotFoundException e) {
++                        Log.debug("Room '{}' refers to group '{}', which no longer exists.", getJID(), candidate, e);
++                    }
++                } else if (!candidate.asBareJID().equals(excluded)) {
++                    return candidate.asBareJID();
++                }
++            }
++        }
++        return null;
++    }
++
+     @Override
+     public void userModified(User user, Map<String, Object> params)
+     {}
+diff --git a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MultiUserChatManager.java b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MultiUserChatManager.java
+index 475aef7..def4314 100644
+--- a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MultiUserChatManager.java
++++ b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/MultiUserChatManager.java
+@@ -20,8 +20,11 @@ import org.jivesoftware.database.DbConnectionManager;
+ import org.jivesoftware.database.SequenceManager;
+ import org.jivesoftware.openfire.XMPPServer;
+ import org.jivesoftware.openfire.container.BasicModule;
++import org.jivesoftware.openfire.event.GroupEventDispatcher;
++import org.jivesoftware.openfire.event.GroupEventListener;
+ import org.jivesoftware.openfire.event.UserEventDispatcher;
+ import org.jivesoftware.openfire.event.UserEventListener;
++import org.jivesoftware.openfire.group.Group;
+ import org.jivesoftware.openfire.muc.cluster.ServiceAddedEvent;
+ import org.jivesoftware.openfire.muc.cluster.ServiceRemovedEvent;
+ import org.jivesoftware.openfire.muc.cluster.ServiceUpdatedEvent;
+@@ -54,7 +57,7 @@ import java.util.stream.Collectors;
+  * @author Daniel Henninger
+  */
+ public class MultiUserChatManager extends BasicModule implements MUCServicePropertyEventListener,
+-        UserEventListener {
++        UserEventListener, GroupEventListener {
+ 
+     private static final Logger Log = LoggerFactory.getLogger(MultiUserChatManager.class);
+ 
+@@ -140,6 +143,7 @@ public class MultiUserChatManager extends BasicModule implements MUCServicePrope
+         addNumberOutgoingMessages();
+ 
+         UserEventDispatcher.addListener(this);
++        GroupEventDispatcher.addListener(this);
+         MUCServicePropertyEventDispatcher.addListener(this);
+     }
+ 
+@@ -151,6 +155,7 @@ public class MultiUserChatManager extends BasicModule implements MUCServicePrope
+         super.stop();
+ 
+         UserEventDispatcher.removeListener(this);
++        GroupEventDispatcher.removeListener(this);
+         MUCServicePropertyEventDispatcher.removeListener(this);
+ 
+         // Remove the statistics.
+@@ -1200,8 +1205,20 @@ public class MultiUserChatManager extends BasicModule implements MUCServicePrope
+         // When a user is being deleted, all its affiliations need to be removed from chat rooms (OF-2166). Note that
+         // every room is an event listener for the same event, which should update rooms that are loaded into memory
+         // from the database. This event handler intends to update rooms that are not in memory, but only in the database.
+-        MUCPersistenceManager
+-                .removeAffiliationFromDB(XMPPServer.getInstance().createJID(user.getUsername(), null, true));
++        final JID userJID = XMPPServer.getInstance().createJID(user.getUsername(), null, true);
++
++        // Apart from the affiliations that are recorded per room, each service records the users that administer it
++        // and the users that are allowed to create rooms on it. A user that no longer exists should be in neither.
++        for (final MultiUserChatService service : getMultiUserChatServices()) {
++            try {
++                service.removeSysadmin(userJID);
++                service.removeUserAllowedToCreate(userJID);
++            } catch (Exception e) {
++                Log.warn("A problem occurred while trying to update MUC service '{}' as a result of user '{}' being deleted from Openfire.", service.getServiceName(), user, e);
++            }
++        }
++
++        MUCPersistenceManager.removeAffiliationFromDB(userJID);
+     }
+ 
+     @Override
+@@ -1209,6 +1226,68 @@ public class MultiUserChatManager extends BasicModule implements MUCServicePrope
+         // Do nothing
+     }
+ 
++    @Override
++    public void groupCreated(Group group, Map<String, ?> params) {
++        // Do nothing
++    }
++
++    @Override
++    public void groupDeleting(Group group, Map<String, ?> params) {
++        // Do nothing
++    }
++
++    @Override
++    public void groupModified(Group group, Map<String, ?> params) {
++        // Do nothing
++    }
++
++    @Override
++    public void memberAdded(Group group, Map<String, ?> params) {
++        // Do nothing
++    }
++
++    @Override
++    public void memberRemoved(Group group, Map<String, ?> params) {
++        keepAnOwnerForRoomsOwnedBy(group, (String) params.get("member"));
++    }
++
++    @Override
++    public void adminAdded(Group group, Map<String, ?> params) {
++        // Do nothing
++    }
++
++    @Override
++    public void adminRemoved(Group group, Map<String, ?> params) {
++        keepAnOwnerForRoomsOwnedBy(group, (String) params.get("admin"));
++    }
++
++    /**
++     * A shared group can own chat rooms. When the last person is taken out of such a group, nobody is left who can
++     * administer those rooms - the same state that deleting their last owner leaves behind. Rooms that are in memory
++     * listen to the group's events themselves; this sees to the rooms that are only in the database.
++     *
++     * @param group The group that somebody was taken out of.
++     * @param removed The address that was taken out of the group (as the event reports it), or null.
++     */
++    private void keepAnOwnerForRoomsOwnedBy(@Nonnull final Group group, @Nullable final String removed)
++    {
++        try {
++            if (!group.getAll().isEmpty()) {
++                return;
++            }
++            final Set<Long> roomsInMemory = new HashSet<>();
++            for (final MultiUserChatService service : getMultiUserChatServices()) {
++                for (final MUCRoom room : service.getActiveChatRooms()) {
++                    roomsInMemory.add(room.getID());
++                }
++            }
++            MUCPersistenceManager.keepAnOwnerForRoomsOwnedBy(group.getJID(),
++                removed == null ? null : new JID(removed).asBareJID(), roomsInMemory);
++        } catch (Exception e) {
++            Log.warn("A problem occurred while trying to keep an owner for the rooms owned by group '{}' after somebody was taken out of it.", group.getName(), e);
++        }
++    }
++
+     private static class ServiceComparator implements Comparator<MultiUserChatService> {
+         @Override
+         public int compare(MultiUserChatService o1, MultiUserChatService o2) {
+diff --git a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/spi/MUCPersistenceManager.java b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/spi/MUCPersistenceManager.java
+index bc64ae4..83a7373 100644
+--- a/xmppserver/src/main/java/org/jivesoftware/openfire/muc/spi/MUCPersistenceManager.java
++++ b/xmppserver/src/main/java/org/jivesoftware/openfire/muc/spi/MUCPersistenceManager.java
+@@ -21,6 +21,8 @@ import org.dom4j.Element;
+ import org.jivesoftware.database.DbConnectionManager;
+ import org.jivesoftware.openfire.XMPPServer;
+ import org.jivesoftware.openfire.group.GroupJID;
++import org.jivesoftware.openfire.group.GroupManager;
++import org.jivesoftware.openfire.group.GroupNotFoundException;
+ import org.jivesoftware.openfire.muc.*;
+ import org.jivesoftware.util.JiveGlobals;
+ import org.jivesoftware.util.NamedThreadFactory;
+@@ -170,6 +172,12 @@ public class MUCPersistenceManager {
+         "DELETE FROM ofMucMember WHERE jid=?";
+     private static final String DELETE_USER_MUCAFFILIATION =
+         "DELETE FROM ofMucAffiliation WHERE jid=?";
++    private static final String LOAD_ALL_AFFILIATIONS_OF_KIND =
++        "SELECT roomID,jid FROM ofMucAffiliation WHERE affiliation=?";
++    private static final String LOAD_ROOM_AFFILIATIONS_OF_KIND =
++        "SELECT jid FROM ofMucAffiliation WHERE roomID=? AND affiliation=? ORDER BY jid";
++    private static final String LOAD_ROOM_MEMBERS =
++        "SELECT jid FROM ofMucMember WHERE roomID=? ORDER BY jid";
+     private static final String ADD_CONVERSATION_LOG =
+         "INSERT INTO ofMucConversationLog (roomID,messageID,sender,nickname,logTime,subject,body,stanza) VALUES (?,?,?,?,?,?,?,?)";
+     private static final String DELETE_ROOM_HISTORY =
+@@ -1369,6 +1377,21 @@ public class MUCPersistenceManager {
+         PreparedStatement pstmt = null;
+         try {
+             con = DbConnectionManager.getConnection();
++
++            // Rooms that are not in memory have no event listener of their own: a room that is left without an owner
++            // by the removal below has to be given a new owner here. Ownership can be held through a shared group, so
++            // a room whose only owner is a group that no longer has members is in the same position as a room whose
++            // only owner is the user that is being deleted.
++            for (final Long roomID : roomsLeftWithoutOwnerBy(con, affiliationJID)) {
++                final JID replacementJID = findReplacementOwner(con, roomID, affiliationJID);
++                if (replacementJID == null) {
++                    Log.warn("User '{}' is being deleted, and is the last owner of MUC room with ID {}, but no account could be found to take over ownership of the room.", affiliationJID, roomID);
++                } else {
++                    Log.info("User '{}' is being deleted, but is also the only owner of MUC room with ID {}. To prevent having a room without owner, '{}' was made owner of the room.", affiliationJID, roomID, replacementJID);
++                    saveOwnerToDB(con, roomID, replacementJID);
++                }
++            }
++
+             // Remove the user from the members table
+             pstmt = con.prepareStatement(DELETE_USER_MEMBER);
+             pstmt.setString(1, affiliationJID.toBareJID());
+@@ -1388,6 +1411,247 @@ public class MUCPersistenceManager {
+         }
+     }
+ 
++    /**
++     * Returns the IDs of the persistent rooms that the removal of the provided address leaves without an owner that
++     * refers to an existing account. An owner entry that is a shared group counts only when that group still has a
++     * member other than the provided address.
++     *
++     * A room whose owner entries never stood for the address that is going, and could not have been emptied by its
++     * departure either, is none of this method's business: it was already in whatever state it is in before this
++     * deletion, and handing it a new owner here would change a room that this deletion did not touch.
++     *
++     * @param con an open database connection.
++     * @param excludedJID The (real) JID that is not to be taken into account (typically: a user that is being deleted).
++     * @return the IDs of the rooms that are about to be left without an owner.
++     * @throws SQLException when the affiliations could not be read.
++     */
++    private static Collection<Long> roomsLeftWithoutOwnerBy(Connection con, JID excludedJID) throws SQLException
++    {
++        final Map<Long, Boolean> hasOtherOwner = new LinkedHashMap<>();
++        final Map<Long, Boolean> concerned = new LinkedHashMap<>();
++        try (final PreparedStatement pstmt = con.prepareStatement(LOAD_ALL_AFFILIATIONS_OF_KIND)) {
++            pstmt.setInt(1, Affiliation.owner.getValue());
++            try (final ResultSet rs = pstmt.executeQuery()) {
++                while (rs.next()) {
++                    final long roomID = rs.getLong(1);
++                    final String storedJID = rs.getString(2);
++                    hasOtherOwner.merge(roomID, isAccountOtherThan(storedJID, excludedJID), Boolean::logicalOr);
++                    concerned.merge(roomID, couldHaveLostItsAccount(storedJID, excludedJID), Boolean::logicalOr);
++                }
++            }
++        }
++
++        final List<Long> result = new ArrayList<>();
++        for (final Map.Entry<Long, Boolean> entry : hasOtherOwner.entrySet()) {
++            if (!entry.getValue() && Boolean.TRUE.equals(concerned.get(entry.getKey()))) {
++                result.add(entry.getKey());
++            }
++        }
++        return result;
++    }
++
++    /**
++     * Checks if an owner entry can have stopped standing for an existing account through the removal of the provided
++     * address: the entry is that address, or it is a shared group that still exists - a group that is empty now may
++     * have just lost its last member, and that member may have been the address that is going.
++     *
++     * An entry that names a shared group that no longer exists cannot have been emptied here, because deleting a user
++     * does not delete groups. Such an entry had already stopped standing for anybody before this deletion started.
++     */
++    private static boolean couldHaveLostItsAccount(String storedJID, JID excludedJID)
++    {
++        if (storedJID == null || storedJID.isEmpty()) {
++            return false;
++        }
++        final JID stored = new JID(storedJID);
++        if (GroupJID.isGroup(stored)) {
++            try {
++                GroupManager.getInstance().getGroup(stored);
++                return true;
++            } catch (GroupNotFoundException e) {
++                Log.debug("A MUC room is affiliated with group '{}', which no longer exists.", storedJID, e);
++                return false;
++            }
++        }
++        return excludedJID.asBareJID().equals(stored.asBareJID());
++    }
++
++    /**
++     * Finds an account that can take over ownership of a room that is not in memory: a server administrator when there
++     * is one, and otherwise someone that the room already trusts.
++     *
++     * @param con an open database connection.
++     * @param roomID The ID of the room that needs a new owner.
++     * @param excludedJID The (real) JID that is not to be selected (typically: a user that is being deleted).
++     * @return the address of the new owner, or null when no suitable account exists.
++     * @throws SQLException when the affiliations could not be read.
++     */
++    private static JID findReplacementOwner(Connection con, Long roomID, JID excludedJID) throws SQLException
++    {
++        final List<String> candidates = new ArrayList<>();
++        for (final JID admin : XMPPServer.getInstance().getAdmins()) {
++            candidates.add(admin.toBareJID());
++        }
++        try (final PreparedStatement pstmt = con.prepareStatement(LOAD_ROOM_AFFILIATIONS_OF_KIND)) {
++            pstmt.setLong(1, roomID);
++            pstmt.setInt(2, Affiliation.admin.getValue());
++            try (final ResultSet rs = pstmt.executeQuery()) {
++                while (rs.next()) {
++                    candidates.add(rs.getString(1));
++                }
++            }
++        }
++        try (final PreparedStatement pstmt = con.prepareStatement(LOAD_ROOM_MEMBERS)) {
++            pstmt.setLong(1, roomID);
++            try (final ResultSet rs = pstmt.executeQuery()) {
++                while (rs.next()) {
++                    candidates.add(rs.getString(1));
++                }
++            }
++        }
++
++        for (final String candidate : candidates) {
++            final JID resolved = resolveToAccountOtherThan(candidate, excludedJID);
++            if (resolved != null) {
++                return resolved;
++            }
++        }
++        return null;
++    }
++
++    /**
++     * Stores an owner affiliation for a room, replacing whatever affiliation that address had in that room before.
++     *
++     * @param con an open database connection.
++     * @param roomID The ID of the room.
++     * @param ownerJID The address that is to own the room.
++     * @throws SQLException when the affiliation could not be written.
++     */
++    private static void saveOwnerToDB(Connection con, Long roomID, JID ownerJID) throws SQLException
++    {
++        // An owner is not a member: the room's own code drops the membership when it promotes someone
++        // (MUCRoom#addOwner), and so does the affiliation that is written per room. Leaving the membership behind
++        // would store the same address as owner and as member at once, which no other path in this class produces,
++        // which a reload does not clean up, and which makes a later demotion collide on the membership's key.
++        try (final PreparedStatement pstmt = con.prepareStatement(DELETE_MEMBER)) {
++            pstmt.setLong(1, roomID);
++            pstmt.setString(2, ownerJID.toBareJID());
++            pstmt.executeUpdate();
++        }
++        try (final PreparedStatement pstmt = con.prepareStatement(UPDATE_AFFILIATION)) {
++            pstmt.setInt(1, Affiliation.owner.getValue());
++            pstmt.setLong(2, roomID);
++            pstmt.setString(3, ownerJID.toBareJID());
++            if (pstmt.executeUpdate() > 0) {
++                return;
++            }
++        }
++        try (final PreparedStatement pstmt = con.prepareStatement(ADD_AFFILIATION)) {
++            pstmt.setLong(1, roomID);
++            pstmt.setString(2, ownerJID.toBareJID());
++            pstmt.setInt(3, Affiliation.owner.getValue());
++            pstmt.executeUpdate();
++        }
++    }
++
++    /**
++     * Checks if a stored affiliation entry refers to an existing account other than the provided address. Entries that
++     * refer to a shared group are resolved to the members of that group.
++     */
++    private static boolean isAccountOtherThan(String storedJID, JID excludedJID)
++    {
++        return resolveToAccountOtherThan(storedJID, excludedJID) != null;
++    }
++
++    /**
++     * Resolves a stored affiliation entry to an existing account other than the provided address. Entries that refer to
++     * a shared group are resolved to the first member of that group that qualifies.
++     *
++     * @return the address of a qualifying account, or null when the entry refers to none.
++     */
++    private static JID resolveToAccountOtherThan(String storedJID, JID excludedJID)
++    {
++        if (storedJID == null || storedJID.isEmpty()) {
++            return null;
++        }
++        final JID excluded = excludedJID == null ? null : excludedJID.asBareJID();
++        final JID stored = new JID(storedJID);
++        if (GroupJID.isGroup(stored)) {
++            try {
++                for (final JID groupMember : GroupManager.getInstance().getGroup(stored).getAll()) {
++                    if (!groupMember.asBareJID().equals(excluded)) {
++                        return groupMember.asBareJID();
++                    }
++                }
++            } catch (GroupNotFoundException e) {
++                Log.debug("A MUC room is affiliated with group '{}', which no longer exists.", storedJID, e);
++            }
++            return null;
++        }
++        return stored.asBareJID().equals(excluded) ? null : stored.asBareJID();
++    }
++
++    /**
++     * Gives an owner to every persistent room that is not in memory, that is owned by the provided shared group, and
++     * that has no owner left that refers to an existing account. This is what taking the last person out of a group
++     * does to the rooms that the group owns: nobody is left who can administer them. Rooms that are in memory see to
++     * this themselves (they listen to the group's events).
++     *
++     * @param groupJID The address of the group that somebody was taken out of.
++     * @param removedJID The address that was taken out of the group (it is not handed a room), or null.
++     * @param roomsInMemory The IDs of the rooms that are in memory, which are left alone here.
++     */
++    public static void keepAnOwnerForRoomsOwnedBy(@Nonnull final JID groupJID, @Nullable final JID removedJID,
++                                                  @Nonnull final Collection<Long> roomsInMemory)
++    {
++        try (final Connection con = DbConnectionManager.getConnection()) {
++            for (final Long roomID : roomsOwnedByWithoutAnOwner(con, groupJID)) {
++                if (roomsInMemory.contains(roomID)) {
++                    continue;
++                }
++                final JID replacementJID = findReplacementOwner(con, roomID, removedJID);
++                if (replacementJID == null) {
++                    Log.warn("The last person was taken out of group '{}', which owns MUC room with ID {}, but no account could be found to take over ownership of the room.", groupJID, roomID);
++                } else {
++                    Log.info("The last person was taken out of group '{}', which owns MUC room with ID {}. To prevent having a room without owner, '{}' was made owner of the room.", groupJID, roomID, replacementJID);
++                    saveOwnerToDB(con, roomID, replacementJID);
++                }
++            }
++        } catch (SQLException sqle) {
++            Log.error("A database error occurred while trying to give an owner to the rooms owned by group '{}'.", groupJID, sqle);
++        }
++    }
++
++    /**
++     * Returns the IDs of the persistent rooms that are owned by the provided group and that have no owner entry left
++     * that refers to an existing account.
++     */
++    private static Collection<Long> roomsOwnedByWithoutAnOwner(Connection con, JID groupJID) throws SQLException
++    {
++        final Map<Long, Boolean> hasOwner = new LinkedHashMap<>();
++        final Set<Long> ownedByGroup = new HashSet<>();
++        try (final PreparedStatement pstmt = con.prepareStatement(LOAD_ALL_AFFILIATIONS_OF_KIND)) {
++            pstmt.setInt(1, Affiliation.owner.getValue());
++            try (final ResultSet rs = pstmt.executeQuery()) {
++                while (rs.next()) {
++                    final long roomID = rs.getLong(1);
++                    final String storedJID = rs.getString(2);
++                    hasOwner.merge(roomID, resolveToAccountOtherThan(storedJID, null) != null, Boolean::logicalOr);
++                    if (storedJID != null && (storedJID.equals(groupJID.toString()) || storedJID.equals(groupJID.toBareJID()))) {
++                        ownedByGroup.add(roomID);
++                    }
++                }
++            }
++        }
++        final List<Long> result = new ArrayList<>();
++        for (final Long roomID : ownedByGroup) {
++            if (!Boolean.TRUE.equals(hasOwner.get(roomID))) {
++                result.add(roomID);
++            }
++        }
++        return result;
++    }
++
+     /**
+      * Saves the conversation log entry batch to the database.
+      *
+diff --git a/xmppserver/src/test/java/org/jivesoftware/openfire/muc/UserDeletionOwnershipTest.java b/xmppserver/src/test/java/org/jivesoftware/openfire/muc/UserDeletionOwnershipTest.java
+new file mode 100644
+index 0000000..e9c3a49
+--- /dev/null
++++ b/xmppserver/src/test/java/org/jivesoftware/openfire/muc/UserDeletionOwnershipTest.java
+@@ -0,0 +1,655 @@
++package org.jivesoftware.openfire.muc;
++
++import org.jivesoftware.Fixtures;
++import org.jivesoftware.database.DbConnectionManager;
++import org.jivesoftware.database.DefaultConnectionProvider;
++import org.jivesoftware.openfire.XMPPServer;
++import org.jivesoftware.openfire.event.GroupEventDispatcher;
++import org.jivesoftware.openfire.event.UserEventDispatcher;
++import org.jivesoftware.openfire.group.Group;
++import org.jivesoftware.openfire.group.GroupJID;
++import org.jivesoftware.openfire.group.GroupManager;
++import org.jivesoftware.openfire.group.GroupNotFoundException;
++import org.jivesoftware.openfire.muc.spi.MUCPersistenceManager;
++import org.jivesoftware.openfire.muc.spi.MultiUserChatServiceImpl;
++import org.jivesoftware.openfire.user.User;
++import org.jivesoftware.util.cache.CacheFactory;
++import org.junit.jupiter.api.AfterEach;
++import org.junit.jupiter.api.BeforeAll;
++import org.junit.jupiter.api.BeforeEach;
++import org.junit.jupiter.api.Test;
++import org.xmpp.component.ComponentManager;
++import org.xmpp.component.ComponentManagerFactory;
++import org.xmpp.packet.JID;
++
++import java.nio.file.Files;
++import java.nio.file.Path;
++import java.sql.Connection;
++import java.sql.PreparedStatement;
++import java.sql.ResultSet;
++import java.util.ArrayList;
++import java.util.Arrays;
++import java.util.Collections;
++import java.util.List;
++import java.util.Map;
++import java.util.concurrent.locks.ReentrantLock;
++
++import static org.junit.jupiter.api.Assertions.assertEquals;
++import static org.junit.jupiter.api.Assertions.assertFalse;
++import static org.junit.jupiter.api.Assertions.assertNotNull;
++import static org.junit.jupiter.api.Assertions.assertTrue;
++import static org.mockito.ArgumentMatchers.anyString;
++import static org.mockito.Mockito.doAnswer;
++import static org.mockito.Mockito.doReturn;
++import static org.mockito.Mockito.mock;
++import static org.mockito.Mockito.withSettings;
++
++/**
++ * Tests that verify that deleting a user account does not leave a chat room without anyone that can administer it,
++ * and does not leave the deleted account in charge of anything (OF-2166).
++ *
++ * Each test drives the event listeners for the "user is being deleted" event that the affected component registers,
++ * and then observes the database (and, where the room is in memory, the room itself).
++ */
++public class UserDeletionOwnershipTest {
++
++    static final String DRIVER = "org.hsqldb.jdbcDriver";
++    static String URL;
++    static Path dbDir;
++    static final String DOMAIN = Fixtures.XMPP_DOMAIN;
++    static final String ALICE = "alice@" + DOMAIN;
++    static final String BOB = "bob@" + DOMAIN;
++    static final String CAROL = "carol@" + DOMAIN;
++    static final String DAVE = "dave@" + DOMAIN;
++    static final String ROOT = "root@" + DOMAIN;
++    static final String ADMIN = "admin@" + DOMAIN;
++
++    XMPPServer xmppServer;
++    MultiUserChatManager mucManagerMock;
++    MultiUserChatService serviceMock;
++    final List<JID> admins = new ArrayList<>();
++
++    @BeforeAll
++    static void initDb() throws Exception {
++        Fixtures.reconfigureOpenfireHome();
++        final Path src = Path.of(UserDeletionOwnershipTest.class.getResource("/datasets/openfire.script").toURI()).getParent();
++        dbDir = Files.createTempDirectory("ofuserdel");
++        Files.copy(src.resolve("openfire.script"), dbDir.resolve("openfire.script"));
++        Files.copy(src.resolve("openfire.properties"), dbDir.resolve("openfire.properties"));
++        URL = "jdbc:hsqldb:" + dbDir.resolve("openfire") + ";ifexists=true";
++    }
++
++    @BeforeEach
++    void setUp() throws Exception {
++        CacheFactory.initialize();
++        Fixtures.clearExistingProperties();
++        Arrays.stream(CacheFactory.getAllCaches()).forEach(Map::clear);
++
++        final DefaultConnectionProvider cp = new DefaultConnectionProvider();
++        cp.setDriver(DRIVER);
++        cp.setServerURL(URL);
++        cp.setUsername("sa");
++        cp.setPassword("");
++        DbConnectionManager.setConnectionProvider(cp);
++        MultiUserChatManager.MASTER_KEY.setValue("user-deletion-test-master-key");
++
++        admins.clear();
++        xmppServer = Fixtures.mockXMPPServer();
++        mucManagerMock = mock(MultiUserChatManager.class, withSettings().lenient());
++        doReturn(1L).when(mucManagerMock).getMultiUserChatServiceID(anyString());
++        doReturn(mucManagerMock).when(xmppServer).getMultiUserChatManager();
++        doAnswer(i -> admins).when(xmppServer).getAdmins();
++        XMPPServer.setInstance(xmppServer);
++
++        serviceMock = mock(MultiUserChatService.class, withSettings().lenient());
++        doReturn("conference").when(serviceMock).getServiceName();
++        doReturn("conference." + DOMAIN).when(serviceMock).getServiceDomain();
++        doReturn(new HistoryStrategy()).when(serviceMock).getHistoryStrategy();
++        doAnswer(i -> new ReentrantLock()).when(serviceMock).getChatRoomLock(anyString());
++
++        for (final String table : new String[]{"ofMucAffiliation", "ofMucMember", "ofMucRoom",
++                "ofMucServiceProp", "ofMucService", "ofGroupUser", "ofGroupProp", "ofGroup"}) {
++            sql("DELETE FROM " + table);
++        }
++        // A service's settings are cached per subdomain for the life of the JVM, and the rows were just deleted
++        // underneath that cache.
++        MUCPersistenceManager.refreshProperties("conference");
++    }
++
++    MultiUserChatManager startedManager;
++    MultiUserChatServiceImpl startedService;
++
++    @AfterEach
++    void tearDown() {
++        // A service that was never started as a component has little to shut down, and parts of the server it would
++        // talk to are not there in a unit test: each step is attempted on its own, so that one of them failing does
++        // not leave the next test holding this test's manager and service.
++        if (startedService != null) {
++            try {
++                for (final MUCRoom room : startedService.getActiveChatRooms()) {
++                    UserEventDispatcher.removeListener(room);
++                    GroupEventDispatcher.removeListener(room);
++                }
++            } catch (Exception ignored) { }
++        }
++        if (startedManager != null) {
++            try { startedManager.stop(); } catch (Exception ignored) { }
++            try { startedManager.unregisterMultiUserChatService("conference", false); } catch (Exception ignored) { }
++        }
++        if (startedService != null) {
++            try { startedService.shutdown(); } catch (Exception ignored) { }
++        }
++        startedManager = null;
++        startedService = null;
++        Arrays.stream(CacheFactory.getAllCaches()).forEach(Map::clear);
++    }
++
++    /**
++     * The chat service as the server runs it: its row in the database, and a chat manager that is initialized and
++     * started the way the server starts it. The group manager is created first, as it is at boot, so that its own
++     * listener for deleted accounts (which takes an account out of its groups) runs before the chat manager's.
++     */
++    MultiUserChatServiceImpl startedService() throws Exception {
++        if (startedService != null) {
++            return startedService;
++        }
++        GroupManager.getInstance();
++        ComponentManagerFactory.setComponentManager(mock(ComponentManager.class, withSettings().lenient()));
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "INSERT INTO ofMucService (serviceID,subdomain,description,isHidden) VALUES (1,'conference',NULL,0)")) {
++            p.executeUpdate();
++        }
++        MUCPersistenceManager.refreshProperties("conference");
++        startedManager = new MultiUserChatManager();
++        doReturn(startedManager).when(xmppServer).getMultiUserChatManager();
++        startedManager.initialize(xmppServer);
++        startedManager.start();
++        startedService = (MultiUserChatServiceImpl) startedManager.getMultiUserChatService("conference");
++        return startedService;
++    }
++
++    /** UserManager.deleteUser: one dispatch, heard by every listener that registered for it. */
++    void deleteAccount(String username) throws Exception {
++        startedService();
++        UserEventDispatcher.dispatchEvent(mockUser(username),
++            UserEventDispatcher.EventType.user_deleting, Collections.emptyMap());
++    }
++
++    // ─── fixture helpers ────────────────────────────────────────────────────
++
++    static void sql(String statement) throws Exception {
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(statement)) {
++            p.executeUpdate();
++        }
++    }
++
++    void createPersistentRoom(long roomId, String name) throws Exception {
++        String now = String.valueOf(System.currentTimeMillis());
++        while (now.length() < 15) now = "0" + now;
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "INSERT INTO ofMucRoom (serviceID,roomID,creationDate,modificationDate,name,naturalName," +
++                 "description,lockedDate,emptyDate,canChangeSubject,maxUsers,publicRoom,moderated,membersOnly," +
++                 "canInvite,roomPassword,canDiscoverJID,logEnabled,retireOnDeletion,preserveHistOnDel,subject," +
++                 "rolesToBroadcast,useReservedNick,canChangeNick,canRegister,allowpm) " +
++                 "VALUES (1,?,?,?,?,?,NULL,?,?,1,30,1,0,0,0,NULL,1,1,0,1,NULL,7,0,1,1,0)")) {
++            p.setLong(1, roomId); p.setString(2, now); p.setString(3, now);
++            p.setString(4, name); p.setString(5, name); p.setString(6, now); p.setString(7, now);
++            p.executeUpdate();
++        }
++    }
++
++    void addAffiliation(long roomId, String bareJid, Affiliation affiliation) throws Exception {
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "INSERT INTO ofMucAffiliation (roomID,jid,affiliation) VALUES (?,?,?)")) {
++            p.setLong(1, roomId); p.setString(2, bareJid); p.setInt(3, affiliation.getValue());
++            p.executeUpdate();
++        }
++    }
++
++    void addMember(long roomId, String bareJid, String nickname) throws Exception {
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "INSERT INTO ofMucMember (roomID,jid,nickname) VALUES (?,?,?)")) {
++            p.setLong(1, roomId); p.setString(2, bareJid); p.setString(3, nickname);
++            p.executeUpdate();
++        }
++    }
++
++    List<String> affiliationRows(long roomId) throws Exception {
++        final List<String> out = new ArrayList<>();
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "SELECT jid,affiliation FROM ofMucAffiliation WHERE roomID=? ORDER BY jid,affiliation")) {
++            p.setLong(1, roomId);
++            try (ResultSet rs = p.executeQuery()) {
++                while (rs.next()) out.add(rs.getString(1) + ":" + rs.getInt(2));
++            }
++        }
++        return out;
++    }
++
++    List<String> ownerRows(long roomId) throws Exception {
++        final List<String> out = new ArrayList<>();
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "SELECT jid FROM ofMucAffiliation WHERE roomID=? AND affiliation=? ORDER BY jid")) {
++            p.setLong(1, roomId); p.setInt(2, Affiliation.owner.getValue());
++            try (ResultSet rs = p.executeQuery()) {
++                while (rs.next()) out.add(rs.getString(1));
++            }
++        }
++        return out;
++    }
++
++    List<String> memberRows(long roomId) throws Exception {
++        final List<String> out = new ArrayList<>();
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "SELECT jid,nickname FROM ofMucMember WHERE roomID=? ORDER BY jid")) {
++            p.setLong(1, roomId);
++            try (ResultSet rs = p.executeQuery()) {
++                while (rs.next()) out.add(rs.getString(1) + ":" + rs.getString(2));
++            }
++        }
++        return out;
++    }
++
++    List<String> rawServiceProperty(String name) throws Exception {
++        final List<String> out = new ArrayList<>();
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "SELECT propValue FROM ofMucServiceProp WHERE name=? ORDER BY propValue")) {
++            p.setString(1, name);
++            try (ResultSet rs = p.executeQuery()) {
++                while (rs.next()) out.add(rs.getString(1));
++            }
++        }
++        return out;
++    }
++
++    static User mockUser(String username) {
++        final User u = mock(User.class, withSettings().lenient());
++        doReturn(username).when(u).getUsername();
++        return u;
++    }
++
++    /** The dispatch of UserManager.deleteUser that reaches the rooms that are not in memory. */
++    static void fireDatabasePathListener(String username) {
++        new MultiUserChatManager().userDeleting(mockUser(username), Collections.emptyMap());
++    }
++
++    MUCRoom loadRoom(String name) {
++        final MUCRoom room = new MUCRoom(serviceMock, name);
++        MUCPersistenceManager.loadFromDB(room);
++        return room;
++    }
++
++    /**
++     * Resolves a stored affiliation entry to an existing account other than the one named. An entry that refers to a
++     * shared group resolves to a member of that group. Any account will do: what is checked is that SOMEBODY is left
++     * who can run the room, never who in particular.
++     */
++    static String resolveToAccountOtherThan(String storedJid, String excluded) {
++        if (storedJid == null || storedJid.isEmpty()) {
++            return null;
++        }
++        final JID stored = new JID(storedJid);
++        if (GroupJID.isGroup(stored)) {
++            try {
++                final Group group = GroupManager.getInstance().getGroup(stored);
++                for (final JID member : group.getAll()) {
++                    if (!member.asBareJID().toString().equals(excluded)) {
++                        return member.asBareJID().toString();
++                    }
++                }
++            } catch (GroupNotFoundException e) {
++                return null;
++            }
++            return null;
++        }
++        return stored.asBareJID().toString().equals(excluded) ? null : stored.asBareJID().toString();
++    }
++
++    static String someoneWhoCanRun(List<String> ownerEntries, String excluded) {
++        for (final String entry : ownerEntries) {
++            final String resolved = resolveToAccountOtherThan(entry, excluded);
++            if (resolved != null) {
++                return resolved;
++            }
++        }
++        return null;
++    }
++
++    static List<String> asStrings(Iterable<JID> jids) {
++        final List<String> out = new ArrayList<>();
++        for (final JID jid : jids) {
++            out.add(jid.toString());
++        }
++        return out;
++    }
++
++    // ─── tests ──────────────────────────────────────────────────────────────
++
++    /**
++     * The membership of a room, as it has to come out of a deletion. Every row that went in is still there, with two
++     * exceptions that the ticket itself makes: the row of the account that is leaving, and the row of whoever had to
++     * take the room over - promoting a member is how the product hands a room on, and it drops that membership when it
++     * does (MUCRoom#addOwner). Nothing else may appear, disappear or change. Who was promoted is the change's call, so
++     * this subtracts whoever owns the room now instead of naming anybody.
++     */
++    void assertMembershipSurvived(long roomId, List<String> wentIn, String deleted) throws Exception {
++        final List<String> cameOut = memberRows(roomId);
++        final List<String> owners = ownerRows(roomId);
++        for (final String row : cameOut) {
++            assertTrue(wentIn.contains(row),
++                "room " + roomId + ": a membership that was not there came out of the deletion: went in=" + wentIn
++                + " came out=" + cameOut);
++        }
++        for (final String row : wentIn) {
++            if (cameOut.contains(row)) {
++                continue;
++            }
++            final String jid = row.substring(0, row.indexOf(':'));
++            if (jid.equals(deleted)) {
++                continue;
++            }
++            assertTrue(owners.contains(jid),
++                "room " + roomId + ": '" + jid + "' stopped being a member of a room it did not take over: went in="
++                + wentIn + " came out=" + cameOut + " owners=" + owners);
++        }
++    }
++
++    @Test
++    public void db_path_persistent_room_keeps_an_owner() throws Exception {
++        createPersistentRoom(101, "keepsanowner");
++        addAffiliation(101, ALICE, Affiliation.owner);
++        addMember(101, CAROL, "caro");
++        admins.add(new JID(ADMIN));
++
++        fireDatabasePathListener("alice");
++
++        final List<String> owners = ownerRows(101);
++        assertNotNull(someoneWhoCanRun(owners, ALICE),
++            "The room is left without an owner that refers to an existing account: " + affiliationRows(101));
++        assertFalse(affiliationRows(101).stream().anyMatch(r -> r.startsWith(ALICE + ":")),
++            "The deleted account is still affiliated with the room: " + affiliationRows(101));
++        assertFalse(memberRows(101).stream().anyMatch(r -> r.startsWith(ALICE + ":")),
++            "The deleted account still belongs to the room: " + memberRows(101));
++
++        final MUCRoom room = loadRoom("keepsanowner");
++        assertFalse(room.getOwners().isEmpty(), "The reloaded room has no owner at all.");
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The reloaded room still gives the deleted account an affiliation.");
++    }
++
++    @Test
++    public void db_path_promotion_when_the_admin_already_has_a_row() throws Exception {
++        createPersistentRoom(102, "adminhasarow");
++        addAffiliation(102, ALICE, Affiliation.owner);
++        addAffiliation(102, ADMIN, Affiliation.outcast);
++        admins.add(new JID(ADMIN));
++
++        fireDatabasePathListener("alice");
++
++        final List<String> rows = affiliationRows(102);
++        assertNotNull(someoneWhoCanRun(ownerRows(102), ALICE),
++            "The room is left without an owner that refers to an existing account: " + rows);
++        assertFalse(rows.stream().anyMatch(r -> r.startsWith(ALICE + ":")),
++            "The deleted account is still affiliated with the room: " + rows);
++
++        final MUCRoom room = loadRoom("adminhasarow");
++        assertFalse(room.getOwners().isEmpty(), "The reloaded room has no owner at all.");
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The reloaded room still gives the deleted account an affiliation.");
++    }
++
++    @Test
++    public void promotion_when_the_server_has_no_admin_accounts() throws Exception {
++        createPersistentRoom(103, "noadmins");
++        final MUCRoom room = new MUCRoom(serviceMock, "noadmins");
++        room.setID(103); room.setPersistent(true); room.setSavedToDB(true);
++        room.addOwner(new JID(ALICE), Affiliation.owner);
++        room.addAdmin(new JID(BOB), Affiliation.owner);
++        room.addMember(new JID(CAROL), "caro", Affiliation.owner);
++        admins.clear();
++
++        room.userDeleting(mockUser("alice"), Collections.emptyMap());
++
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The deleted account still has an affiliation with the room: owners=" + asStrings(room.getOwners()));
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), ALICE),
++            "The room is left without an owner that refers to an existing account: " + asStrings(room.getOwners()));
++    }
++
++    @Test
++    public void promotion_when_the_only_admin_is_the_deleted_user() throws Exception {
++        createPersistentRoom(113, "adminisdeleted");
++        final MUCRoom room = new MUCRoom(serviceMock, "adminisdeleted");
++        room.setID(113); room.setPersistent(true); room.setSavedToDB(true);
++        room.addOwner(new JID(ALICE), Affiliation.owner);
++        room.addAdmin(new JID(BOB), Affiliation.owner);
++        admins.clear();
++        admins.add(new JID(ALICE));
++
++        room.userDeleting(mockUser("alice"), Collections.emptyMap());
++
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The deleted account still has an affiliation with the room: owners=" + asStrings(room.getOwners()));
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), ALICE),
++            "The room is left without an owner that refers to an existing account: " + asStrings(room.getOwners()));
++    }
++
++    @Test
++    public void service_level_lists_release_the_deleted_user() throws Exception {
++        ComponentManagerFactory.setComponentManager(mock(ComponentManager.class, withSettings().lenient()));
++        try (Connection c = DbConnectionManager.getConnection();
++             PreparedStatement p = c.prepareStatement(
++                 "INSERT INTO ofMucService (serviceID,subdomain,description,isHidden) VALUES (1,'conference',NULL,0)")) {
++            p.executeUpdate();
++        }
++
++        final MultiUserChatManager manager = new MultiUserChatManager();
++        doReturn(manager).when(xmppServer).getMultiUserChatManager();
++        final MultiUserChatServiceImpl service = new MultiUserChatServiceImpl(1L, "conference", null, false);
++        manager.registerMultiUserChatService(service, false);
++
++        MUCPersistenceManager.setProperty("conference", "sysadmin.jid", ALICE + "," + ROOT);
++        MUCPersistenceManager.setProperty("conference", "create.jid", ALICE + "," + DAVE);
++        service.initializeSettings();
++        assertTrue(service.isSysadmin(new JID(ALICE)), "fixture: the account is not a sysadmin to begin with");
++
++        // Dispatched the way the server dispatches it, so that a change that hangs its own listener
++        // off this event is seen exactly like a change that extends the one that is already there.
++        UserEventDispatcher.addListener(manager);
++        try {
++            UserEventDispatcher.dispatchEvent(mockUser("alice"),
++                UserEventDispatcher.EventType.user_deleting, Collections.emptyMap());
++        } finally {
++            UserEventDispatcher.removeListener(manager);
++        }
++
++        final List<String> sysadmins = rawServiceProperty("sysadmin.jid");
++        final List<String> creators = rawServiceProperty("create.jid");
++        assertFalse(sysadmins.toString().contains(ALICE),
++            "The deleted account still administers the chat service: sysadmin.jid=" + sysadmins);
++        assertFalse(creators.toString().contains(ALICE),
++            "The deleted account may still create rooms on the chat service: create.jid=" + creators);
++        assertTrue(sysadmins.toString().contains(ROOT),
++            "The other administrator of the chat service was dropped as well: sysadmin.jid=" + sysadmins);
++        assertTrue(creators.toString().contains(DAVE),
++            "The other account allowed to create rooms was dropped as well: create.jid=" + creators);
++        assertFalse(service.isSysadmin(new JID(ALICE)),
++            "The running service still treats the deleted account as its administrator.");
++    }
++
++    @Test
++    public void group_owned_room_out_of_memory_keeps_an_owner() throws Exception {
++        final GroupManager groupManager = GroupManager.getInstance();
++        final Group group = groupManager.createGroup("roomowners");
++        group.getMembers().add(new JID(ALICE));
++        final String groupJid = new GroupJID("roomowners").toString();
++
++        createPersistentRoom(107, "groupownedoutofmemory");
++        addAffiliation(107, groupJid, Affiliation.owner);
++        admins.add(new JID(ADMIN));
++
++        groupManager.deleteUser(mockUser("alice"));
++        fireDatabasePathListener("alice");
++
++        assertNotNull(someoneWhoCanRun(ownerRows(107), ALICE),
++            "The room is left without an owner that refers to an existing account: " + affiliationRows(107));
++    }
++
++    @Test
++    public void group_owned_room_in_memory_keeps_an_owner() throws Exception {
++        final GroupManager groupManager = GroupManager.getInstance();
++        final Group group = groupManager.createGroup("roomowners2");
++        group.getMembers().add(new JID(ALICE));
++        final String groupJid = new GroupJID("roomowners2").toString();
++
++        createPersistentRoom(207, "groupownedinmemory");
++        addAffiliation(207, groupJid, Affiliation.owner);
++        admins.add(new JID(ADMIN));
++
++        final MUCRoom room = loadRoom("groupownedinmemory");
++        assertEquals(Affiliation.owner, room.getAffiliation(new JID(ALICE)),
++            "fixture: the account does not own the room through the group to begin with");
++
++        groupManager.deleteUser(mockUser("alice"));
++        room.userDeleting(mockUser("alice"), Collections.emptyMap());
++
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), ALICE),
++            "The room is left without an owner that refers to an existing account: " + asStrings(room.getOwners()));
++    }
++
++    @Test
++    public void rooms_that_keep_another_owner_come_out_unchanged() throws Exception {
++        createPersistentRoom(301, "soleowner");
++        addAffiliation(301, ALICE, Affiliation.owner);
++
++        createPersistentRoom(302, "onlyamember");
++        addAffiliation(302, BOB, Affiliation.owner);
++        addMember(302, ALICE, "ali");
++        addMember(302, CAROL, "caro");
++
++        createPersistentRoom(303, "twoowners");
++        addAffiliation(303, ALICE, Affiliation.owner);
++        addAffiliation(303, BOB, Affiliation.owner);
++
++        createPersistentRoom(304, "soleownerwithmembers");
++        addAffiliation(304, ALICE, Affiliation.owner);
++        addMember(304, CAROL, "caro");
++        addMember(304, DAVE, "dav");
++
++        admins.add(new JID(ADMIN));
++
++        fireDatabasePathListener("alice");
++
++        assertNotNull(someoneWhoCanRun(ownerRows(301), ALICE),
++            "The room that lost its only owner is left without one: " + affiliationRows(301));
++        assertEquals(List.of(BOB + ":" + Affiliation.owner.getValue()), affiliationRows(302),
++            "A room that kept its owner did not come out unchanged.");
++        assertEquals(List.of(CAROL + ":caro"), memberRows(302),
++            "A room that kept its owner did not come out unchanged.");
++        assertEquals(List.of(BOB + ":" + Affiliation.owner.getValue()), affiliationRows(303),
++            "A room that kept one of its two owners did not come out unchanged.");
++        assertNotNull(someoneWhoCanRun(ownerRows(304), ALICE),
++            "The room that lost its only owner is left without one: " + affiliationRows(304));
++        assertMembershipSurvived(304, List.of(CAROL + ":caro", DAVE + ":dav"), ALICE);
++    }
++
++    @Test
++    public void in_memory_room_with_no_admin_accounts_is_taken_over_by_a_member() throws Exception {
++        createPersistentRoom(103, "onlymembersleft");
++        addAffiliation(103, ALICE, Affiliation.owner);
++        addMember(103, CAROL, "caro");
++        admins.clear();
++        final MUCRoom room = startedService().getChatRoom("onlymembersleft");
++        assertNotNull(room, "fixture: the room did not load");
++
++        deleteAccount("alice");
++
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The deleted account still has an affiliation with the room.");
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), ALICE),
++            "The room is left without an owner: " + asStrings(room.getOwners()));
++        assertNotNull(someoneWhoCanRun(ownerRows(103), ALICE),
++            "After a restart the room has no owner: " + affiliationRows(103));
++    }
++
++    @Test
++    public void db_path_room_is_taken_over_when_the_only_admin_is_the_one_leaving() throws Exception {
++        createPersistentRoom(113, "onlyadminleaves");
++        addAffiliation(113, ALICE, Affiliation.owner);
++        addMember(113, CAROL, "caro");
++        admins.clear();
++        admins.add(new JID(ALICE));
++
++        deleteAccount("alice");
++
++        assertNotNull(someoneWhoCanRun(ownerRows(113), ALICE),
++            "The room is left without an owner: " + affiliationRows(113));
++        assertFalse(affiliationRows(113).stream().anyMatch(r -> r.startsWith(ALICE + ":")),
++            "The deleted account is still affiliated with the room: " + affiliationRows(113));
++    }
++
++    @Test
++    public void group_emptied_by_a_removal_keeps_its_room_owned_out_of_memory() throws Exception {
++        startedService();
++        final GroupManager groupManager = GroupManager.getInstance();
++        groupManager.createGroup("removedowners").getMembers().add(new JID(ALICE));
++        createPersistentRoom(108, "groupemptiedoutofmemory");
++        addAffiliation(108, new GroupJID("removedowners").toString(), Affiliation.owner);
++        addMember(108, CAROL, "caro");
++        admins.add(new JID(ADMIN));
++
++        groupManager.getGroup("removedowners").getMembers().remove(new JID(ALICE));
++
++        assertNotNull(someoneWhoCanRun(ownerRows(108), null),
++            "The room still names only a group that has nobody in it: " + affiliationRows(108));
++    }
++
++    @Test
++    public void group_emptied_by_a_removal_keeps_its_room_owned_in_memory() throws Exception {
++        final MultiUserChatServiceImpl service = startedService();
++        final GroupManager groupManager = GroupManager.getInstance();
++        groupManager.createGroup("removedowners2").getMembers().add(new JID(ALICE));
++        createPersistentRoom(208, "groupemptiedinmemory");
++        addAffiliation(208, new GroupJID("removedowners2").toString(), Affiliation.owner);
++        addMember(208, CAROL, "caro");
++        admins.add(new JID(ADMIN));
++        final MUCRoom room = service.getChatRoom("groupemptiedinmemory");
++        assertNotNull(room, "fixture: the room did not load");
++
++        groupManager.getGroup("removedowners2").getMembers().remove(new JID(ALICE));
++
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), null),
++            "The room still names only a group that has nobody in it: " + asStrings(room.getOwners()));
++        assertNotNull(someoneWhoCanRun(ownerRows(208), null),
++            "After a restart the room names only a group that has nobody in it: " + affiliationRows(208));
++    }
++
++    @Test
++    public void in_memory_promotion_when_the_admin_is_banned_from_the_room() throws Exception {
++        createPersistentRoom(116, "adminisbanned");
++        addAffiliation(116, ALICE, Affiliation.owner);
++        addAffiliation(116, ADMIN, Affiliation.outcast);
++        admins.add(new JID(ALICE));
++        admins.add(new JID(ADMIN));
++        final MUCRoom room = startedService().getChatRoom("adminisbanned");
++        assertNotNull(room, "fixture: the room did not load");
++
++        deleteAccount("alice");
++
++        assertEquals(Affiliation.none, room.getAffiliation(new JID(ALICE)),
++            "The deleted account still has an affiliation with the room.");
++        assertNotNull(someoneWhoCanRun(asStrings(room.getOwners()), ALICE),
++            "The room is left without an owner: " + asStrings(room.getOwners()));
++        assertNotNull(someoneWhoCanRun(ownerRows(116), ALICE),
++            "After a restart the room has no owner: " + affiliationRows(116));
++    }
++}
+
+REFERENCE_PATCH

harbor/tasks/openfire_userdeleting_last_owner_contract/task.toml

@@ -0,0 +1,26 @@
+version = "1.0"
+artifacts = ["/workspace/submissions/submitted.patch"]
+[metadata]
+task = "openfire_userdeleting_last_owner_contract"
+validation_revision = "coding-rubric-v2"
+[agent]
+timeout_sec = 1800
+user = "1000:1000"
+[environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "no-network"
+[verifier]
+timeout_sec = 7200
+user = "0"
+environment_mode = "separate"
+[verifier.environment]
+build_timeout_sec = 1800
+cpus = 2
+memory_mb = 8192
+network_mode = "no-network"
+[[verifier.collect]]
+command = "/opt/task-tools/python -I /opt/task-tools/capture.py"
+user = "0"
+timeout_sec = 900

harbor/tasks/openfire_userdeleting_last_owner_contract/tests/Dockerfile

@@ -0,0 +1,10 @@
+FROM ec-swe-openfire:source-v9
+USER root
+RUN grep -q '^[^:]*:[^:]*:1000:' /etc/passwd || echo 'grader:x:1000:1000::/tmp/agent-home:/bin/sh' >> /etc/passwd; grep -q '^[^:]*:[^:]*:1000:' /etc/group || echo 'grader:x:1000:' >> /etc/group
+RUN chmod -R a+rX /hud/m2
+ENV HUD_TELEMETRY_ENABLED=false HUD_CLI_ANALYTICS_ENABLED=0 HUD_FILE_TRACKING_ENABLED=false
+RUN rm -f /hud/gold.diff
+COPY verify.py evidence.py config.json test.sh /tests/
+RUN chmod 755 /tests/test.sh
+WORKDIR /app
+CMD ["sleep", "infinity"]

harbor/tasks/openfire_userdeleting_last_owner_contract/tests/config.json

@@ -0,0 +1,180 @@
+{
+  "revision": "coding-rubric-v2",
+  "task_id": "openfire_userdeleting_last_owner_contract",
+  "arguments": {},
+  "grader_version": "0.6.15",
+  "source_image": "ec-swe-openfire:source-v9",
+  "source_image_id": "sha256:ebda27591100cc680c577a73428d3d69f0d2ec0753b0dfaaf40df5573b912beb",
+  "provenance": {
+    "repository": "igniterealtime/Openfire",
+    "environment_id": "832b2185-06cc-43ba-9c75-b0f58b3854ed",
+    "build": 9,
+    "build_id": "ab430f1d-8559-41f0-bea8-7224a7ce44e3",
+    "hosted_task": "openfire_userdeleting_last_owner_contract-0163de9c",
+    "task_version": 1,
+    "source_archive_sha256": "9c3e03f8f4d3ce0838f65f06a21b5e8e88a2e829c610ddc3192ea917c176bacc",
+    "hosted_revision_argument": "not recorded; the scenario does not read it"
+  },
+  "criteria": [
+    [
+      "db_path_persistent_room_keeps_an_owner",
+      0.03,
+      true,
+      "bash",
+      900
+    ],
+    [
+      "db_path_promotion_when_the_admin_already_has_a_row",
+      0.03,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "in_memory_room_with_no_admin_accounts_is_taken_over_by_a_member",
+      0.09,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "db_path_room_with_no_admin_accounts_is_taken_over_by_a_member",
+      0.09,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "db_path_room_is_taken_over_when_the_only_admin_is_the_one_leaving",
+      0.09,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "in_memory_room_is_taken_over_when_the_only_admin_is_the_one_leaving",
+      0.09,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "db_path_room_whose_only_admin_is_a_shared_group_is_taken_over",
+      0.03,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "service_level_lists_release_the_deleted_user",
+      0.06,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "group_owned_room_out_of_memory_keeps_an_owner",
+      0.03,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "group_owned_room_in_memory_keeps_an_owner",
+      0.03,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "group_emptied_by_a_removal_keeps_its_room_owned_out_of_memory",
+      0.09,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "group_emptied_by_a_removal_keeps_its_room_owned_in_memory",
+      0.085,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "group_emptied_by_an_admin_removal_keeps_its_room_owned_out_of_memory",
+      0.09,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "group_emptied_by_an_admin_removal_keeps_its_room_owned_in_memory",
+      0.085,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "in_memory_promotion_when_the_admin_is_banned_from_the_room",
+      0.03,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "rooms_that_keep_another_owner_come_out_unchanged",
+      0.03,
+      false,
+      "bash",
+      900
+    ],
+    [
+      "gate_repo_suite_green_and_tests_untouched",
+      0.02,
+      true,
+      "bash",
+      1800
+    ]
+  ],
+  "gates": [],
+  "reward_rule": "weighted_cap",
+  "local_hostname": false,
+  "fault_exit": 3,
+  "grader_readable": [
+    "/hud/m2"
+  ],
+  "grader_writable": [],
+  "blocker_cap": 0.6,
+  "empty_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "verifier_files": {
+    "/app/env.py": "08a8fea48013da1bfbfdf4791922dd9e8d95dc2a17af0b7d17d7de7adbecc91a",
+    "/app/tasks.py": "317473bdc4396fde46516b3d0968ffd404182c167b678c11a7078c35984ae704",
+    "/app/coding/github.py": "dfb450735dd44af94d51088ccd37df0470a4bf7c1339f5277aea2419bd64c694",
+    "/app/coding/repo.py": "b1366540d1ea28ccb7cc578a311662ef4a2b9e7e5a4c27543dcbd594cc6d86da",
+    "/app/coding/swe_bench_pro.py": "9b1131236eb514c62ba3a3bfb7aba61bad29df18a0293afc1bcb8a277c4ff929",
+    "/app/coding/__init__.py": "9ba11441d392f54835f33527d4a098f48528824a8f8c3c255cf4c140f89523bf",
+    "/app/task/prompt.md": "1220fccfd54e0cd15470a50e30d03e6699921a0ed26ddb248508379ccf44e8c5",
+    "/hud/grader/board_smoke.py": "c95453ba720db49ea6856a2f37ce7d25398344ddd7c9d978cb58175c8cef8b65",
+    "/hud/grader/run_grading.sh": "4a5b5b5e7fd69eff9ff060d46910830f47d91670af06f9dfe6833fb285ae94e9",
+    "/hud/grader/harness/HiddenOwnershipChecks.java": "2929de9902853a63560c940d189a02fe9efdf323957eb23b1aaba277c85ca934"
+  },
+  "preflight": [
+    [
+      "/bin/bash",
+      "--version"
+    ],
+    [
+      "setpriv",
+      "--version"
+    ],
+    [
+      "git",
+      "--version"
+    ],
+    [
+      "bash",
+      "-c",
+      "bash -lc 'java -version' || java -version"
+    ]
+  ]
+}

harbor/tasks/openfire_userdeleting_last_owner_contract/tests/docker-compose.yaml

@@ -0,0 +1,6 @@
+services:
+  main:
+    network_mode: none
+    pids_limit: 512
+    security_opt:
+      - no-new-privileges:true

harbor/tasks/openfire_userdeleting_last_owner_contract/tests/evidence.py

@@ -0,0 +1,123 @@
+"""Validate complete coding-rubric evidence without importing the grader library or Harbor."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+REVISION = "coding-rubric-v2"
+
+
+def _number(value: Any) -> float:
+    if isinstance(value, bool) or not isinstance(value, (float, int)):
+        raise ValueError("Expected numeric rubric evidence")
+    if not math.isfinite(value) or not 0 <= value <= 1:
+        raise ValueError("Rubric values must be finite and within [0, 1]")
+    return float(value)
+
+
+def validate_report(report: dict[str, Any], config: dict[str, Any], digest: str) -> None:
+    """Check provenance, criterion coverage, weights, caps and command outcomes.
+
+    Parameters
+    ----------
+    report, config : dict
+        Fresh verifier evidence and the trusted prepared task configuration.
+    digest : str
+        SHA-256 of the submission collected by Harbor.
+
+    Raises
+    ------
+    ValueError
+        If evidence is missing, inconsistent or reports infrastructure failure.
+    """
+    if (
+        report.get("revision") != REVISION
+        or report.get("task_id") != config["task_id"]
+        or report.get("patch_sha256") != digest
+        or report.get("grader_version") != config["grader_version"]
+    ):
+        raise ValueError("Verifier evidence provenance mismatch")
+    result = report.get("result", {})
+    reward = _number(result.get("reward"))
+    # A rubric may flag its own result when a grader could not judge. That is
+    # admitted only together with proof, checked below, that the same grader
+    # reaches a verdict on the untouched repository.
+    fault_exit = config.get("fault_exit")
+    faults = {
+        row["name"]
+        for row in report.get("commands", [])
+        if fault_exit is not None and (row.get("info") or {}).get("exit_code") == fault_exit
+    }
+    flagged = result.get("isError", False)
+    if (flagged and not faults) or result.get("done", True) is not True:
+        raise ValueError("Grader returned an incomplete or failed evaluation")
+    status = report.get("status")
+    if status == "rejected_patch":
+        if reward != 0 or not report.get("patch_error") or result.get("subscores"):
+            raise ValueError("Invalid rejected-patch evidence")
+        return
+    if status == "empty_patch":
+        credited = any(_number(row["value"]) for row in result.get("subscores") or [])
+        if reward != 0 or digest != config["empty_sha256"] or report.get("commands") or credited:
+            raise ValueError("Invalid empty-patch evidence")
+        return
+    if status != "graded":
+        raise ValueError("Verifier did not complete")
+    scores = result.get("subscores")
+    expected = {row[0]: row for row in config["criteria"]}
+    if not isinstance(scores, list) or len(scores) != len(expected):
+        raise ValueError("Missing rubric criteria")
+    names = [row["name"] for row in scores]
+    if len(set(names)) != len(names) or set(names) != set(expected):
+        raise ValueError("Duplicate or unexpected rubric criteria")
+    raw = 0.0
+    values = {}
+    for score in scores:
+        name = score["name"]
+        value, weight = _number(score["value"]), _number(score["weight"])
+        if not math.isclose(weight, expected[name][1], abs_tol=1e-12):
+            raise ValueError("Criterion weights changed")
+        raw += value * weight
+        values[name] = value
+    commands = report.get("commands", [])
+    command_names = [row["name"] for row in commands]
+    expected_commands = set(expected) | set(config["gates"])
+    if len(command_names) != len(set(command_names)) or set(command_names) != expected_commands:
+        raise ValueError("Missing or duplicate grader command evidence")
+    for command in commands:
+        info = command.get("info") or {}
+        code = info.get("exit_code")
+        verdict = type(code) is int and (code in (0, 1) or command["name"] in faults)
+        if not verdict or info.get("timed_out"):
+            raise ValueError("Grader command failed outside its verdict contract")
+        if _number(command["value"]) != float(code == 0):
+            raise ValueError("Command exit code disagrees with score")
+    probes = {row["name"]: row for row in report.get("fault_probes") or []}
+    if set(probes) != faults or any(
+        row.get("timed_out") or row.get("exit_code") not in (0, 1) for row in probes.values()
+    ):
+        raise ValueError(
+            "A grader could not judge and the untouched repository does not explain it"
+        )
+    if any(values.get(name, 0) for name in faults):
+        raise ValueError("A criterion its grader could not judge is credited")
+    info = result.get("info") or {}
+    if info.get("aggregate_mismatch") or info.get("git_apply"):
+        raise ValueError("Grader reported inconsistent grading")
+    if config.get("reward_rule") == "authored":
+        # The task's own function decides the reward. It may take credit away
+        # (a cap, a criterion that pays only with progress) but never add any.
+        passed = {row["name"]: row["value"] for row in commands}
+        if any(values[name] > passed[name] for name in expected):
+            raise ValueError("A criterion is credited although its command failed")
+        if reward > raw + 1e-9:
+            raise ValueError("Grader reward exceeds its weighted criteria")
+        return
+    failed = {name for name, row in expected.items() if row[2] and values[name] < 1}
+    gate_failed = {
+        row["name"] for row in commands if row["name"] in config["gates"] and row["value"] < 1
+    }
+    expected_reward = min(raw, config["blocker_cap"]) if failed or gate_failed else raw
+    if not math.isclose(reward, expected_reward, abs_tol=1e-9):
+        raise ValueError("Grader reward disagrees with original weights and blocker cap")

harbor/tasks/openfire_userdeleting_last_owner_contract/tests/test.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+/opt/hudvenv/bin/python /tests/verify.py

harbor/tasks/openfire_userdeleting_last_owner_contract/tests/verify.py

@@ -0,0 +1,235 @@
+"""Run the original trusted coding rubric in a fresh, offline verifier container."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import importlib
+import importlib.metadata
+import json
+import os
+import shlex
+import shutil
+import signal
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from evidence import REVISION, validate_report
+
+OUT = Path("/logs/verifier")
+PRIVATE = Path("/var/lib/task-evidence")
+CONFIG = Path("/tests/config.json")
+PATCH = Path("/workspace/submissions/submitted.patch")
+GRADER_HOME = "/tmp/agent-home"
+
+
+def _run(command: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(command, text=True, capture_output=True, timeout=300, **kwargs)
+
+
+def _preflight(config: dict[str, Any]) -> None:
+    if importlib.metadata.version("hud") != config["grader_version"]:
+        raise RuntimeError("Grader library version does not match the task")
+    for filename, expected in config["verifier_files"].items():
+        if hashlib.sha256(Path(filename).read_bytes()).hexdigest() != expected:
+            raise RuntimeError(f"Verifier source changed: {filename}")
+    for command in config["preflight"]:
+        completed = _run(command, cwd="/workspace/repo")
+        if completed.returncode:
+            raise RuntimeError(f"Prerequisite failed: {command}: {completed.stderr[-2000:]}")
+
+
+def _readable_mode(path: Path) -> int:
+    # World-readable, keeping what is executable so: a grader may ship tools.
+    return 0o755 if path.is_dir() or path.stat().st_mode & 0o111 else 0o644
+
+
+def _permissions() -> None:
+    # The orchestrator owns reports and rubric definitions. Grader commands,
+    # and so the candidate's code, run as uid 1000: the user the task installed
+    # its toolchain and caches for. They cannot read gold/vault or overwrite
+    # the rubric or the result files, which stay root's.
+    Path("/hud").chmod(0o711)
+    for root in (Path("/hud/grader"), Path("/hud/base"), Path("/hud/base-src")):
+        if root.exists():
+            root.chmod(0o755)
+            for path in root.rglob("*"):
+                if not path.is_symlink():
+                    path.chmod(_readable_mode(path))
+    home = Path(GRADER_HOME)
+    home.mkdir(parents=True, exist_ok=True)
+    os.chown(home, 1000, 1000)
+    for directory in ("/hud/logs", "/hud/gocache", "/hud/grader/runner"):
+        path = Path(directory)
+        path.mkdir(parents=True, exist_ok=True)
+        for item in (path, *path.rglob("*")):
+            if not item.is_symlink():
+                os.chown(item, 1000, 1000)
+                item.chmod(_readable_mode(item))
+
+
+def _hand_over_checkout() -> None:
+    # The original grader runs as root and may run the candidate's own suite in
+    # place, which writes into the tree. The rubric resets and re-applies the
+    # candidate as root, so give what root touched back to the grading user.
+    # Installed dependency trees are large and already that user's.
+    subprocess.run(
+        [
+            "find",
+            "/workspace/repo",
+            "-path",
+            "*/node_modules",
+            "-prune",
+            "-o",
+            "!",
+            "-user",
+            "1000",
+            "-exec",
+            "chown",
+            "-h",
+            "1000:1000",
+            "{}",
+            "+",
+        ],
+        check=True,
+        capture_output=True,
+        timeout=3600,
+    )
+
+
+async def _grade(config: dict[str, Any], record: dict[str, Any]) -> None:
+    _preflight(config)
+    sys.path.insert(0, "/app")
+    task: Any = importlib.import_module("tasks")
+    await task._setup()
+    _permissions()
+    patch = PATCH.read_bytes()
+    if patch:
+        checked = _run(["git", "apply", "--check", str(PATCH)], cwd="/workspace/repo")
+        if checked.returncode:
+            record.update(
+                status="rejected_patch",
+                patch_error=checked.stderr[-4000:],
+                result={"reward": 0.0, "subscores": None},
+            )
+            return
+        _run(["git", "apply", str(PATCH)], cwd="/workspace/repo", check=True)
+    original = task.BashGrader
+    fault_exit = config.get("fault_exit")
+    faulted: list[tuple[tuple[Any, ...], dict[str, Any], str]] = []
+
+    class ObservedGrader:
+        @classmethod
+        async def grade(cls, *args: Any, **kwargs: Any) -> Any:
+            command = kwargs["command"]
+            _hand_over_checkout()
+            kwargs["command"] = (
+                "setpriv --reuid 1000 --regid 1000 --clear-groups --no-new-privs "
+                f"env HOME={GRADER_HOME} bash -lc " + shlex.quote(command)
+            )
+            score = await original.grade(*args, **kwargs)
+            snapshot = score.model_dump(mode="json")
+            record["commands"].append(snapshot)
+            (PRIVATE / "commands.json").write_text(json.dumps(record["commands"], indent=2))
+            info = snapshot.get("info") or {}
+            if info.get("timed_out") or type(info.get("exit_code")) is not int:
+                raise RuntimeError(f"Grader infrastructure failure: {snapshot['name']}")
+            if fault_exit is not None and info["exit_code"] == fault_exit:
+                # The grader says it could not judge. Whether the submission or
+                # the environment is the reason is settled after grading.
+                faulted.append((args, dict(kwargs), snapshot["name"]))
+            elif info["exit_code"] not in (0, 1):
+                raise RuntimeError(f"Grader command exit {info['exit_code']}: {snapshot['name']}")
+            return score
+
+    task.BashGrader = ObservedGrader
+    result = await task._grade(None)
+    if faulted:
+        # Ask the same commands about the untouched repository. A verdict there
+        # means the grader works here and the submission is what it could not
+        # judge, so the criterion stays unmet. No verdict there means the
+        # environment is at fault, and the attempt is invalid.
+        await task.repo_lib.git(task.REPO_DIR, "reset", "--hard", "HEAD")
+        await task.repo_lib.git(task.REPO_DIR, "clean", "-fd")
+        # Graders keep state between criteria, some of them a copy of the tree
+        # they judged. It describes the submission, so it goes too.
+        for leftover in Path(getattr(task, "LOGS_DIR", "/hud/logs")).iterdir():
+            if leftover.is_dir() and not leftover.is_symlink():
+                shutil.rmtree(leftover)
+            else:
+                leftover.unlink()
+        record["fault_probes"] = []
+        for args, kwargs, name in faulted:
+            _hand_over_checkout()
+            probe = (await original.grade(*args, **kwargs)).model_dump(mode="json")
+            info = probe.get("info") or {}
+            record["fault_probes"].append(
+                {
+                    "name": name,
+                    "exit_code": info.get("exit_code"),
+                    "timed_out": info.get("timed_out"),
+                    "stdout": (info.get("stdout") or "")[-2000:],
+                }
+            )
+            (PRIVATE / "fault_probes.json").write_text(json.dumps(record["fault_probes"], indent=2))
+            if info.get("timed_out") or info.get("exit_code") not in (0, 1):
+                raise RuntimeError(f"Grader cannot judge the untouched repository: {name}")
+    record["result"] = result.model_dump(mode="json")
+    # A rubric may answer an empty change without running any criterion.
+    record["status"] = "empty_patch" if not patch and not record["commands"] else "graded"
+
+
+def _stop_candidate_processes() -> None:
+    # A candidate may fork. End its UID's processes before publishing evidence
+    # to a host bind mount, whose permissions may differ on Docker Desktop.
+    for directory in Path("/proc").iterdir():
+        if not directory.name.isdecimal():
+            continue
+        try:
+            status = (directory / "status").read_text()
+            uid = next(line.split()[1] for line in status.splitlines() if line.startswith("Uid:"))
+            if uid == "1000":
+                os.kill(int(directory.name), signal.SIGKILL)
+        except (FileNotFoundError, ProcessLookupError):
+            pass
+
+
+def main() -> None:
+    """Persist structured evidence and publish reward only after validation."""
+    OUT.mkdir(parents=True, exist_ok=True)
+    PRIVATE.mkdir(parents=True, exist_ok=True, mode=0o700)
+    PRIVATE.chmod(0o700)
+    reward_path = OUT / "reward.txt"
+    reward_path.unlink(missing_ok=True)
+    config = json.loads(CONFIG.read_text())
+    shutil.copy2(CONFIG, OUT / "config.json")
+    record: dict[str, Any] = {
+        "revision": REVISION,
+        "task_id": config["task_id"],
+        "grader_version": importlib.metadata.version("hud"),
+        "commands": [],
+        "status": "error",
+    }
+    try:
+        if PATCH.is_symlink() or not PATCH.is_file() or PATCH.stat().st_size > 32 * 1024 * 1024:
+            raise ValueError("Missing, oversized or symlink submission")
+        record["patch_sha256"] = hashlib.sha256(PATCH.read_bytes()).hexdigest()
+        try:
+            asyncio.run(_grade(config, record))
+        finally:
+            _stop_candidate_processes()
+        reward_path.unlink(missing_ok=True)
+        validate_report(record, config, record["patch_sha256"])
+        (OUT / "report.json").write_text(json.dumps(record, indent=2))
+        reward_path.write_text(str(record["result"]["reward"]) + "\n")
+    except BaseException as error:
+        reward_path.unlink(missing_ok=True)
+        record.update(status="error", error={"type": type(error).__name__, "message": str(error)})
+        (OUT / "report.json").write_text(json.dumps(record, indent=2))
+        raise
+
+
+if __name__ == "__main__":
+    main()