diff --git a/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumLeadersHandler.java b/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumLeadersHandler.java
index e8057b3a21..ac6f43dbe0 100644
--- a/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumLeadersHandler.java
+++ b/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumLeadersHandler.java
@@ -1,24 +1,47 @@
 package ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Objects;
+import java.util.Set;
 import lombok.experimental.UtilityClass;
 import net.dv8tion.jda.api.components.buttons.Button;
+import net.dv8tion.jda.api.events.interaction.GenericInteractionCreateEvent;
 import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
 import ti4.discord.interactions.buttons.Buttons;
 import ti4.discord.interactions.routing.ButtonHandler;
 import ti4.game.Game;
+import ti4.game.Leader;
 import ti4.game.Player;
 import ti4.game.Tile;
 import ti4.helpers.ButtonHelper;
 import ti4.helpers.ButtonHelperModifyUnits;
+import ti4.helpers.Constants;
 import ti4.helpers.NewStuffHelper;
+import ti4.image.Mapper;
 import ti4.message.MessageHelper;
+import ti4.model.ExploreModel;
+import ti4.model.TechnologyModel;
+import ti4.service.emoji.ExploreEmojis;
+import ti4.service.leader.ExhaustLeaderService;
+import ti4.service.tech.PlayerTechService;
 
 @UtilityClass
 public class ArcanumLeadersHandler {
     private static final String PLACE_COMMANDER_FIGHTER = "arcanumCommanderPlaceFighter_";
+    private static final String RETURN_TECH_HERO = "arcanumHeroReturnTech_";
+    private static final String DONE_RETURNING_TECHS = "arcanumHeroFinishTechReturn_";
+    private static final String GAIN_PURGED_FRAGMENT_HERO = "arcanumHeroGainPurgedFragment_";
+    private static final String USE_VEYLA = "arcanumVeylaUse_";
+    private static final String USE_VEYLA_ON_OTHER = "arcanumVeylaUseOnOther";
+    private static final String CHOOSE_VEYLA_TARGET = "arcanumVeylaTarget_";
+    private static final String SELECT_VEYLA_RETURN_TECH = "arcanumVeylaReturnTech_";
+    private static final String GAIN_VEYLA_TECH = "arcanumVeylaGainTech_";
+    private static final List<String> EXPLORE_TYPES =
+            List.of(Constants.CULTURAL, Constants.HAZARDOUS, Constants.INDUSTRIAL, Constants.FRONTIER);
 
+    // Commander
     public static void offerArcanumTechExhaustCommanderButtons(Player player) {
         if (player == null
                 || player.getGame() == null
@@ -91,4 +114,542 @@ private static String getCommanderFighterMessage(Player player) {
         return player.getRepresentation()
                 + ", you may use Orthis Lithon, the Arcanum commander, to place 1 fighter in a system that contains 1 or more of your ships.";
     }
+
+    // Agent
+    public static void offerVeylaTheKeeperButtons(Game game, Player target, String gainedTechID) {
+        TechnologyModel gainedTech = Mapper.getTech(gainedTechID);
+        if (game == null
+                || target == null
+                || "setup".equalsIgnoreCase(game.getPhaseOfGame())
+                || "playerSetup".equalsIgnoreCase(game.getPhaseOfGame())
+                || gainedTech == null
+                || gainedTech.isFactionTech()
+                || !target.hasTech(gainedTechID)
+                || !target.hasUnexhaustedLeader("arcanumagent")
+                || getVeylaReplacementButtons(game, target, gainedTechID).isEmpty()) {
+            return;
+        }
+
+        MessageHelper.sendMessageToChannelWithButtons(
+                target.getCorrectChannel(),
+                target.getRepresentationUnfogged()
+                        + " gained "
+                        + gainedTech.getNameRepresentation()
+                        + ". You may use _Veyla, the Arcanum agent_ to replace it.",
+                List.of(
+                        Buttons.gray(
+                                target.factionButtonChecker() + USE_VEYLA + target.getFaction() + "|" + gainedTechID,
+                                "Use Arcanum Agent"),
+                        Buttons.red("deleteButtons", "Decline")));
+    }
+
+    public static Button getVeylaCardsInfoButton(Player player) {
+        return Buttons.gray(player.factionButtonChecker() + USE_VEYLA_ON_OTHER, "Use Arcanum Agent");
+    }
+
+    @ButtonHandler(USE_VEYLA_ON_OTHER)
+    public static void selectVeylaTarget(ButtonInteractionEvent event, Game game, Player agentOwner) {
+        if (game == null
+                || agentOwner == null
+                || "setup".equalsIgnoreCase(game.getPhaseOfGame())
+                || !agentOwner.hasUnexhaustedLeader("arcanumagent")) {
+            ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
+            return;
+        }
+
+        List<Button> targetButtons = game.getRealPlayers().stream()
+                .filter(target -> target != agentOwner)
+                .filter(target ->
+                        !getVeylaReturnTechButtons(game, agentOwner, target).isEmpty())
+                .map(target -> Buttons.green(
+                        agentOwner.factionButtonChecker() + CHOOSE_VEYLA_TARGET + target.getFaction(),
+                        target.getFactionNameOrColor(),
+                        target.getFactionEmojiOrColor()))
+                .toList();
+        if (targetButtons.isEmpty()) {
+            MessageHelper.sendEphemeralMessageToEventChannel(
+                    event, "No other player has an eligible technology to return.");
+            return;
+        }
+
+        MessageHelper.sendMessageToChannelWithButtons(
+                agentOwner.getCardsInfoThread(),
+                agentOwner.getRepresentationUnfogged() + ", choose a player to use _Veyla, the Arcanum agent_ on.",
+                targetButtons);
+    }
+
+    @ButtonHandler(CHOOSE_VEYLA_TARGET)
+    public static void chooseVeylaTarget(ButtonInteractionEvent event, Game game, Player agentOwner, String buttonID) {
+        if (game == null
+                || agentOwner == null
+                || "setup".equalsIgnoreCase(game.getPhaseOfGame())
+                || !agentOwner.hasUnexhaustedLeader("arcanumagent")) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        Player target = game.getPlayerFromColorOrFaction(buttonID.substring(CHOOSE_VEYLA_TARGET.length()));
+        List<Button> returnTechButtons = getVeylaReturnTechButtons(game, agentOwner, target);
+        if (target == null || returnTechButtons.isEmpty()) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        if (returnTechButtons.size() == 1) {
+            String returnedTechID = getVeylaReturnedTechID(returnTechButtons.getFirst());
+            resolveVeylaTheKeeper(event, game, agentOwner, target, returnedTechID);
+            return;
+        }
+
+        String message = target.getRepresentation()
+                + ", _Veyla, the Arcanum agent_ is being used on you. Choose a non-faction technology to return.";
+        String buttonPrefix = target.factionButtonChecker() + SELECT_VEYLA_RETURN_TECH + agentOwner.getFaction() + "|";
+        List<Button> buttons = returnTechButtons.size() <= 25
+                ? returnTechButtons
+                : NewStuffHelper.buttonPagination(returnTechButtons, buttonPrefix, 0);
+        MessageHelper.sendMessageToChannelWithButtons(target.getCorrectChannel(), message, buttons);
+        ButtonHelper.deleteMessage(event);
+    }
+
+    @ButtonHandler(SELECT_VEYLA_RETURN_TECH)
+    public static void selectVeylaTechToReturn(
+            ButtonInteractionEvent event, Game game, Player target, String buttonID) {
+        String[] payload = buttonID.substring(SELECT_VEYLA_RETURN_TECH.length()).split("\\|", 2);
+        if (game == null || target == null || payload.length != 2) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        Player agentOwner = game.getPlayerFromColorOrFaction(payload[0]);
+        if (agentOwner == null
+                || "setup".equalsIgnoreCase(game.getPhaseOfGame())
+                || !agentOwner.hasUnexhaustedLeader("arcanumagent")) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        List<Button> returnTechButtons = getVeylaReturnTechButtons(game, agentOwner, target);
+        String message = target.getRepresentation()
+                + ", _Veyla, the Arcanum agent_ is being used on you. Choose a non-faction technology to return.";
+        String buttonPrefix = target.factionButtonChecker() + SELECT_VEYLA_RETURN_TECH + agentOwner.getFaction() + "|";
+        if (NewStuffHelper.checkAndHandlePaginationChange(
+                event, event.getMessageChannel(), returnTechButtons, message, buttonPrefix, buttonID)) {
+            return;
+        }
+
+        resolveVeylaTheKeeper(event, game, agentOwner, target, payload[1]);
+    }
+
+    @ButtonHandler(USE_VEYLA)
+    public static void useVeylaTheKeeper(ButtonInteractionEvent event, Game game, Player agentOwner, String buttonID) {
+        String[] payload = buttonID.substring(USE_VEYLA.length()).split("\\|", 2);
+        if (game == null
+                || agentOwner == null
+                || "setup".equalsIgnoreCase(game.getPhaseOfGame())
+                || payload.length != 2) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        Player target = game.getPlayerFromColorOrFaction(payload[0]);
+        String returnedTechID = payload[1];
+        if (target != agentOwner) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+        resolveVeylaTheKeeper(event, game, agentOwner, target, returnedTechID);
+    }
+
+    @ButtonHandler(GAIN_VEYLA_TECH)
+    public static void gainVeylaTheKeeperTech(ButtonInteractionEvent event, Game game, Player target, String buttonID) {
+        String[] payload = buttonID.substring(GAIN_VEYLA_TECH.length()).split("\\|", 3);
+        if (game == null || target == null || payload.length != 3 || !Objects.equals(target.getFaction(), payload[0])) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        String returnedTechID = payload[1];
+        String selectedTechID = payload[2];
+        List<Button> replacementButtons = getVeylaReplacementButtons(game, target, returnedTechID);
+        String message = target.getRepresentation()
+                + ", choose a non-unit-upgrade technology to gain from _Veyla, the Arcanum agent_.";
+        String buttonPrefix =
+                target.factionButtonChecker() + GAIN_VEYLA_TECH + target.getFaction() + "|" + returnedTechID + "|";
+        if (NewStuffHelper.checkAndHandlePaginationChange(
+                event, event.getMessageChannel(), replacementButtons, message, buttonPrefix, buttonID)) {
+            return;
+        }
+
+        if (!game.getTechnologyDeck().contains(selectedTechID)
+                || replacementButtons.stream()
+                        .noneMatch(button -> button.getCustomId().endsWith("|" + selectedTechID))) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        PlayerTechService.addTech(event, game, target, selectedTechID);
+        ButtonHelper.deleteMessage(event);
+    }
+
+    private static List<Button> getVeylaReplacementButtons(Game game, Player target, String returnedTechID) {
+        TechnologyModel returnedTech = Mapper.getTech(returnedTechID);
+        if (game == null || target == null || returnedTech == null) {
+            return List.of();
+        }
+
+        int maximumRequirements = returnedTech.getRequirements().orElse("").length() + 1;
+        return game.getTechnologyDeck().stream()
+                .map(Mapper::getTech)
+                .filter(Objects::nonNull)
+                .filter(tech -> !tech.isFactionTech() && !tech.isUnitUpgrade())
+                .filter(tech -> !target.hasTech(tech.getAlias()))
+                .filter(tech -> tech.getRequirements().orElse("").length() <= maximumRequirements)
+                .map(tech -> Buttons.green(
+                        target.factionButtonChecker()
+                                + GAIN_VEYLA_TECH
+                                + target.getFaction()
+                                + "|"
+                                + returnedTechID
+                                + "|"
+                                + tech.getAlias(),
+                        tech.getName(),
+                        tech.getCondensedReqsEmojis(true)))
+                .toList();
+    }
+
+    private static List<Button> getVeylaReturnTechButtons(Game game, Player agentOwner, Player target) {
+        if (game == null || agentOwner == null || target == null) {
+            return List.of();
+        }
+
+        return target.getTechs().stream()
+                .map(Mapper::getTech)
+                .filter(Objects::nonNull)
+                .filter(tech -> !tech.isFactionTech())
+                .filter(tech -> !getVeylaReplacementButtons(game, target, tech.getAlias())
+                        .isEmpty())
+                .map(tech -> Buttons.green(
+                        target.factionButtonChecker()
+                                + SELECT_VEYLA_RETURN_TECH
+                                + agentOwner.getFaction()
+                                + "|"
+                                + tech.getAlias(),
+                        "Return " + tech.getName(),
+                        tech.getCondensedReqsEmojis(true)))
+                .toList();
+    }
+
+    private static String getVeylaReturnedTechID(Button button) {
+        int payloadStart = button.getCustomId().indexOf(SELECT_VEYLA_RETURN_TECH) + SELECT_VEYLA_RETURN_TECH.length();
+        String[] payload = button.getCustomId().substring(payloadStart).split("\\|", 2);
+        return payload.length == 2 ? payload[1] : "";
+    }
+
+    private static void resolveVeylaTheKeeper(
+            ButtonInteractionEvent event, Game game, Player agentOwner, Player target, String returnedTechID) {
+        TechnologyModel returnedTech = Mapper.getTech(returnedTechID);
+        Leader agent = agentOwner.getLeader("arcanumagent").orElse(null);
+        List<Button> replacementButtons = getVeylaReplacementButtons(game, target, returnedTechID);
+        if (target == null
+                || agent == null
+                || agent.isExhausted()
+                || returnedTech == null
+                || returnedTech.isFactionTech()
+                || !target.hasTech(returnedTechID)
+                || replacementButtons.isEmpty()) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        ExhaustLeaderService.exhaustLeader(game, agentOwner, agent);
+        target.removeTech(returnedTechID);
+        ButtonHelper.deleteMessage(event);
+
+        String message = target.getRepresentation()
+                + ", _Veyla, the Arcanum agent_ returned "
+                + returnedTech.getNameRepresentation()
+                + " to the technology deck. Choose a non-unit-upgrade technology with at most "
+                + (returnedTech.getRequirements().orElse("").length() + 1)
+                + " prerequisites to gain.";
+        String buttonPrefix =
+                target.factionButtonChecker() + GAIN_VEYLA_TECH + target.getFaction() + "|" + returnedTechID + "|";
+        List<Button> buttons = replacementButtons.size() <= 25
+                ? replacementButtons
+                : NewStuffHelper.buttonPagination(replacementButtons, buttonPrefix, 0);
+        MessageHelper.sendMessageToChannelWithButtons(target.getCorrectChannel(), message, buttons);
+    }
+
+    // Hero
+    public static void startArcanumHero(GenericInteractionCreateEvent event, Game game, Player player) {
+        if (game == null || player == null) {
+            return;
+        }
+
+        List<Button> techButtons = getArcanumHeroTechButtons(player, 0);
+        Button done = getArcanumHeroDoneButton(player, 0);
+        List<Button> buttons = techButtons.size() <= 24
+                ? new ArrayList<>(techButtons)
+                : NewStuffHelper.buttonPagination(
+                        techButtons,
+                        List.of(done),
+                        player.factionButtonChecker() + RETURN_TECH_HERO + "0_",
+                        25,
+                        0,
+                        false);
+        if (techButtons.size() <= 24) {
+            buttons.add(done);
+        }
+        MessageHelper.sendMessageToChannelWithButtons(
+                event.getMessageChannel(), getArcanumHeroTechReturnMessage(player, 0), buttons);
+    }
+
+    @ButtonHandler(RETURN_TECH_HERO)
+    public static void returnArcanumHeroTech(ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        if (game == null || player == null) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        String[] payload = buttonID.substring(RETURN_TECH_HERO.length()).split("_", 2);
+        if (payload.length != 2) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        int returnedCount;
+        try {
+            returnedCount = Integer.parseInt(payload[0]);
+        } catch (NumberFormatException e) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        List<Button> techButtons = getArcanumHeroTechButtons(player, returnedCount);
+        Button done = getArcanumHeroDoneButton(player, returnedCount);
+        String message = getArcanumHeroTechReturnMessage(player, returnedCount);
+        String buttonPrefix = player.factionButtonChecker() + RETURN_TECH_HERO + returnedCount + "_";
+        if (NewStuffHelper.checkAndHandlePaginationChange(
+                event, event.getMessageChannel(), techButtons, List.of(done), message, buttonPrefix, buttonID)) {
+            return;
+        }
+
+        String techID = payload[1];
+        if (returnedCount >= 6 || !player.hasTech(techID) || Mapper.getTech(techID) == null) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        player.removeTech(techID);
+        showArcanumHeroTechReturnPrompt(event, player, returnedCount + 1);
+    }
+
+    @ButtonHandler(DONE_RETURNING_TECHS)
+    public static void finishArcanumHeroTechReturn(
+            ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        if (game == null || player == null) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        int returnedCount;
+        try {
+            returnedCount = Integer.parseInt(buttonID.substring(DONE_RETURNING_TECHS.length()));
+        } catch (NumberFormatException e) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        if (returnedCount < 0 || returnedCount > 6) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        if (returnedCount == 0) {
+            ButtonHelper.deleteMessage(event);
+            MessageHelper.sendMessageToChannel(
+                    event.getMessageChannel(),
+                    player.getRepresentationUnfogged()
+                            + " returned no technologies for _Power Conduits - True Resurrection_.");
+            return;
+        }
+
+        showArcanumHeroFragmentPrompt(event, game, player, returnedCount, 0);
+    }
+
+    private static void showArcanumHeroTechReturnPrompt(
+            GenericInteractionCreateEvent event, Player player, int returnedCount) {
+        List<Button> techButtons = getArcanumHeroTechButtons(player, returnedCount);
+        Button done = getArcanumHeroDoneButton(player, returnedCount);
+        String message = getArcanumHeroTechReturnMessage(player, returnedCount);
+        List<Button> buttons = techButtons.size() <= 24
+                ? new ArrayList<>(techButtons)
+                : NewStuffHelper.buttonPagination(
+                        techButtons,
+                        List.of(done),
+                        player.factionButtonChecker() + RETURN_TECH_HERO + returnedCount + "_",
+                        25,
+                        0,
+                        false);
+        if (techButtons.size() <= 24) {
+            buttons.add(done);
+        }
+
+        if (event instanceof ButtonInteractionEvent buttonEvent) {
+            MessageHelper.editMessageWithButtons(buttonEvent, message, buttons);
+        } else {
+            MessageHelper.sendMessageToChannelWithButtons(event.getMessageChannel(), message, buttons);
+        }
+    }
+
+    private static List<Button> getArcanumHeroTechButtons(Player player, int returnedCount) {
+        return player.getTechs().stream()
+                .map(Mapper::getTech)
+                .filter(Objects::nonNull)
+                .map(tech -> Buttons.green(
+                        player.factionButtonChecker() + RETURN_TECH_HERO + returnedCount + "_" + tech.getAlias(),
+                        tech.getName(),
+                        tech.getCondensedReqsEmojis(true)))
+                .toList();
+    }
+
+    private static Button getArcanumHeroDoneButton(Player player, int returnedCount) {
+        return Buttons.red(
+                player.factionButtonChecker() + DONE_RETURNING_TECHS + returnedCount,
+                "Done Returning Techs (" + returnedCount + "/6)");
+    }
+
+    private static String getArcanumHeroTechReturnMessage(Player player, int returnedCount) {
+        return player.getRepresentation()
+                + ", please choose up to 6 technologies to return to your technology deck. "
+                + "You have returned "
+                + returnedCount
+                + ".";
+    }
+
+    @ButtonHandler(GAIN_PURGED_FRAGMENT_HERO)
+    public static void gainArcanumHeroPurgedFragment(
+            ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        if (game == null || player == null) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        String[] payload =
+                buttonID.substring(GAIN_PURGED_FRAGMENT_HERO.length()).split("_", 2);
+        if (payload.length != 2) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        int remainingCount;
+        try {
+            remainingCount = Integer.parseInt(payload[0]);
+        } catch (NumberFormatException e) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        if (payload[1].startsWith("page")) {
+            try {
+                showArcanumHeroFragmentPrompt(
+                        event, game, player, remainingCount, Integer.parseInt(payload[1].substring(4)));
+            } catch (NumberFormatException e) {
+                ButtonHelper.deleteMessage(event);
+            }
+            return;
+        }
+
+        String fragmentID = payload[1];
+        if (remainingCount < 1 || !getPurgedRelicFragments(game).contains(fragmentID)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        player.addFragment(fragmentID);
+        game.setNumberOfPurgedFragments(Math.max(0, game.getNumberOfPurgedFragments() - 1));
+        if (remainingCount == 1) {
+            ButtonHelper.deleteMessage(event);
+            MessageHelper.sendMessageToChannel(
+                    event.getMessageChannel(),
+                    player.getRepresentationUnfogged()
+                            + " gained the selected purged relic fragments for _Power Conduits - True Resurrection_.");
+            return;
+        }
+
+        showArcanumHeroFragmentPrompt(event, game, player, remainingCount - 1, 0);
+    }
+
+    private static void showArcanumHeroFragmentPrompt(
+            GenericInteractionCreateEvent event, Game game, Player player, int remainingCount, int page) {
+        List<Button> fragmentButtons = getPurgedRelicFragments(game).stream()
+                .map(Mapper::getExplore)
+                .filter(Objects::nonNull)
+                .map(fragment -> Buttons.green(
+                        player.factionButtonChecker()
+                                + GAIN_PURGED_FRAGMENT_HERO
+                                + remainingCount
+                                + "_"
+                                + fragment.getAlias(),
+                        fragment.getName(),
+                        ExploreEmojis.getFragEmoji(fragment.getType())))
+                .toList();
+        if (fragmentButtons.isEmpty()) {
+            if (event instanceof ButtonInteractionEvent buttonEvent) {
+                ButtonHelper.deleteMessage(buttonEvent);
+            }
+            MessageHelper.sendMessageToChannel(
+                    event.getMessageChannel(),
+                    player.getRepresentationUnfogged()
+                            + " cannot gain another purged relic fragment because none are available.");
+            return;
+        }
+
+        String message = player.getRepresentation()
+                + ", choose a purged relic fragment to gain for _Power Conduits - True Resurrection_. "
+                + remainingCount
+                + " remaining.";
+        List<Button> buttons = fragmentButtons.size() <= 25
+                ? fragmentButtons
+                : NewStuffHelper.buttonPagination(
+                        fragmentButtons,
+                        null,
+                        player.factionButtonChecker() + GAIN_PURGED_FRAGMENT_HERO + remainingCount + "_",
+                        25,
+                        page,
+                        false);
+        if (event instanceof ButtonInteractionEvent buttonEvent) {
+            MessageHelper.editMessageWithButtons(buttonEvent, message, buttons);
+        } else {
+            MessageHelper.sendMessageToChannelWithButtons(event.getMessageChannel(), message, buttons);
+        }
+    }
+
+    private static List<String> getPurgedRelicFragments(Game game) {
+        if (game == null) {
+            return List.of();
+        }
+        var explorationDeck = Mapper.getDeck(game.getExplorationDeckID());
+        if (explorationDeck == null) {
+            return List.of();
+        }
+
+        Set<String> unavailableFragments = new HashSet<>();
+        for (String exploreType : EXPLORE_TYPES) {
+            unavailableFragments.addAll(game.getExploreDeck(exploreType));
+            unavailableFragments.addAll(game.getExploreDiscard(exploreType));
+        }
+        for (Player player : game.getPlayers().values()) {
+            unavailableFragments.addAll(player.getFragments());
+            unavailableFragments.addAll(player.getRelics());
+        }
+
+        return explorationDeck.getNewDeck().stream()
+                .distinct()
+                .filter(fragmentID -> !unavailableFragments.contains(fragmentID))
+                .filter(fragmentID -> {
+                    ExploreModel fragment = Mapper.getExplore(fragmentID);
+                    return fragment != null && Constants.FRAGMENT.equalsIgnoreCase(fragment.getResolution());
+                })
+                .toList();
+    }
 }
diff --git a/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumPrimordialTechHandler.java b/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumPrimordialTechHandler.java
new file mode 100644
index 0000000000..4ee856c128
--- /dev/null
+++ b/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumPrimordialTechHandler.java
@@ -0,0 +1,1002 @@
+package ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.experimental.UtilityClass;
+import net.dv8tion.jda.api.components.buttons.Button;
+import net.dv8tion.jda.api.events.interaction.GenericInteractionCreateEvent;
+import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
+import ti4.discord.interactions.buttons.Buttons;
+import ti4.discord.interactions.routing.ButtonHandler;
+import ti4.game.Game;
+import ti4.game.Planet;
+import ti4.game.Player;
+import ti4.game.Tile;
+import ti4.game.UnitHolder;
+import ti4.helpers.ActionCardHelper;
+import ti4.helpers.AliasHandler;
+import ti4.helpers.ButtonHelper;
+import ti4.helpers.ButtonHelperModifyUnits;
+import ti4.helpers.ButtonHelperTacticalAction;
+import ti4.helpers.ComponentActionHelper;
+import ti4.helpers.FoWHelper;
+import ti4.helpers.Helper;
+import ti4.helpers.NewStuffHelper;
+import ti4.helpers.Units;
+import ti4.helpers.Units.UnitKey;
+import ti4.helpers.Units.UnitState;
+import ti4.helpers.Units.UnitType;
+import ti4.image.Mapper;
+import ti4.message.MessageHelper;
+import ti4.model.TechnologyModel;
+import ti4.model.UnitModel;
+import ti4.service.combat.StartCombatService;
+import ti4.service.emoji.CardEmojis;
+import ti4.service.emoji.TechEmojis;
+import ti4.service.emoji.UnitEmojis;
+import ti4.service.unit.AddUnitService;
+import ti4.service.unit.DestroyUnitService;
+import ti4.service.unit.ParsedUnit;
+
+@UtilityClass
+public class ArcanumPrimordialTechHandler {
+    private static final List<String> PRIMORDIAL_TECHS =
+            List.of("tharcanumpmy", "tharcanumpmg", "tharcanumpmr", "tharcanumpmb");
+    // Miracle
+    private static final String MIRACLE = "tharcanumpmg";
+    private static final String DISCARD_AC = "miracleAcDiscard";
+    private static final String GAIN_CC = "miracleGainCC";
+    private static final String PLACE_INF = "miraclePlaceFourInf";
+    private static final String SELECT_AC = "miracleSelectAcToDiscard_";
+    private static final String PLACE_INFANTRY = "miraclePlaceInfantry_";
+    private static final String FINISH_INFANTRY = "miracleFinishInfantry_";
+    private static final String INFANTRY_PLACED = "miracleInfantryPlaced_";
+    // Fabricate
+    private static final String FABRICATE_STATION = "fabricatestation";
+    private static final String FABRICATE_TECH = "tharcanumpmy";
+    private static final String FABRICATE_SELECT_SOURCE = "fabricateStationSource_";
+    private static final String FABRICATE_SELECT_SYSTEM = "fabricateStationSystem_";
+    private static final String FABRICATE_PLACE_UNIT = "fabricateStationPlace_";
+    // Disintegrate
+    private static final String DISINTEGRATE = "tharcanumpmr";
+    private static final String DISINTEGRATE_HIT = "arcanumDisintegrateHit_";
+    private static final String DISINTEGRATE_DESTROY = "arcanumDisintegrateDestroy_";
+    private static final String DISINTEGRATE_DESTROY_UNIT = "arcanumDisintegrateDestroyUnit_";
+    // Plane Shift
+    private static final String PLANE_SHIFT = "tharcanumpmb";
+    private static final String PLANE_SHIFT_SELECT_SYSTEM = "planeShiftSystem_";
+    private static final String PLANE_SHIFT_PENDING = "planeShiftPending";
+    private static final String PLANE_SHIFT_PLAYER = "planeShiftPlayer";
+    private static final String PLANE_SHIFT_SYSTEM = "planeShiftSystem";
+
+    // Forbidden Knowledge
+    public static boolean hasFourTechsMatchingPrimordial(Player player) {
+        return player != null
+                && PRIMORDIAL_TECHS.stream()
+                        .filter(player::hasTech)
+                        .anyMatch(primordialTech -> hasFourTechsMatchingPrimordial(player, primordialTech));
+    }
+
+    public static boolean hasFourTechsMatchingPrimordial(Player player, String primordialTech) {
+        if (player == null || primordialTech == null) {
+            return false;
+        }
+
+        String resolvedPrimordialTech = AliasHandler.resolveTech(primordialTech);
+        if (!PRIMORDIAL_TECHS.contains(resolvedPrimordialTech) || !player.hasTech(resolvedPrimordialTech)) {
+            return false;
+        }
+
+        TechnologyModel primordialModel = Mapper.getTech(resolvedPrimordialTech);
+        TechnologyModel.TechnologyType primordialType = primordialModel == null ? null : primordialModel.getFirstType();
+        if (primordialType == null) {
+            return false;
+        }
+
+        return player.getTechs().stream()
+                        .map(AliasHandler::resolveTech)
+                        // Primordial technologies never contribute to Forbidden Knowledge, including other colors.
+                        .filter(tech -> !PRIMORDIAL_TECHS.contains(tech))
+                        .map(Mapper::getTech)
+                        .filter(tech -> tech != null && tech.getTypes().contains(primordialType))
+                        .count()
+                >= 4;
+    }
+
+    // Power Word: Miracle
+    public static void resolvePowerWordMiracle(GenericInteractionCreateEvent event, Game game, Player player) {
+        if (game == null
+                || player == null
+                || !player.hasTech(MIRACLE)
+                || !player.getExhaustedTechs().contains(MIRACLE)
+                || !hasFourTechsMatchingPrimordial(player, MIRACLE)) {
+            return;
+        }
+        ComponentActionHelper.serveNextComponentActionButtons(event, game, player);
+
+        List<Button> buttons = new ArrayList<>();
+        buttons.add(Buttons.green(
+                player.factionButtonChecker() + DISCARD_AC,
+                "Discard 1 Action Card and Draw 2",
+                CardEmojis.getACEmoji(game)));
+        buttons.add(Buttons.green(player.factionButtonChecker() + GAIN_CC, "Gain 1 Command Token"));
+        buttons.add(Buttons.green(
+                player.factionButtonChecker() + PLACE_INF, "Place Up to 4 Infantry", UnitEmojis.infantry));
+
+        MessageHelper.sendMessageToChannelWithButtons(
+                event.getMessageChannel(),
+                player.getRepresentation() + ", please choose an effect for _Power Word: Miracle_.",
+                buttons);
+    }
+
+    @ButtonHandler(DISCARD_AC)
+    public static void getAcDiscardButtons(ButtonInteractionEvent event, Game game, Player player) {
+        if (game == null
+                || player == null
+                || !player.hasTech(MIRACLE)
+                || !player.getExhaustedTechs().contains(MIRACLE)
+                || !hasFourTechsMatchingPrimordial(player, MIRACLE)) {
+            return;
+        }
+        ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
+
+        List<Button> discardButtons = new ArrayList<>();
+        for (Map.Entry<String, Integer> actionCard : player.getActionCards().entrySet()) {
+            discardButtons.add(Buttons.blue(
+                    player.factionButtonChecker() + SELECT_AC + actionCard.getValue(),
+                    "(" + actionCard.getValue() + ") "
+                            + Mapper.getActionCard(actionCard.getKey()).getName(),
+                    CardEmojis.getACEmoji(game)));
+        }
+
+        MessageHelper.sendMessageToChannelWithButtons(
+                player.getCardsInfoThread(),
+                player.getRepresentation() + ", please choose an action card to discard.",
+                discardButtons);
+    }
+
+    @ButtonHandler(SELECT_AC)
+    public static void resolveMiracleAcDiscard(
+            ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        if (player == null
+                || game == null
+                || !player.hasTech(MIRACLE)
+                || !player.getExhaustedTechs().contains(MIRACLE)
+                || !hasFourTechsMatchingPrimordial(player, MIRACLE)) {
+            return;
+        }
+
+        int handIndex;
+        try {
+            handIndex = Integer.parseInt(buttonID.substring(SELECT_AC.length()));
+        } catch (NumberFormatException e) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        if (!player.getExhaustedTechs().contains(MIRACLE)
+                || !player.getActionCards().containsValue(handIndex)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        ActionCardHelper.discardAC(event, game, player, handIndex);
+        ActionCardHelper.drawActionCards(player, 2);
+        ButtonHelper.deleteMessage(event);
+    }
+
+    @ButtonHandler(GAIN_CC)
+    public static void resolveMiracleCCGain(ButtonInteractionEvent event, Game game, Player player) {
+        if (player == null
+                || game == null
+                || !player.hasTech(MIRACLE)
+                || !player.getExhaustedTechs().contains(MIRACLE)
+                || !hasFourTechsMatchingPrimordial(player, MIRACLE)) {
+            return;
+        }
+        ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
+
+        MessageHelper.sendMessageToChannelWithButtons(
+                event.getMessageChannel(),
+                player.getRepresentation() + ", please choose where to gain 1 command token.",
+                ButtonHelper.getGainCCButtons(player));
+    }
+
+    @ButtonHandler(PLACE_INF)
+    public static void getMiracleInfantryPlacementButtons(ButtonInteractionEvent event, Game game, Player player) {
+        if (game == null
+                || player == null
+                || !player.hasTech(MIRACLE)
+                || !player.getExhaustedTechs().contains(MIRACLE)
+                || !hasFourTechsMatchingPrimordial(player, MIRACLE)) {
+            return;
+        }
+
+        ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
+        int round = game.getRound();
+        game.setStoredValue(INFANTRY_PLACED + player.getFaction() + "_" + round, "0");
+        List<Button> planetButtons = getMiracleInfantryButtons(game, player, round);
+        if (planetButtons.isEmpty()) {
+            game.removeStoredValue(INFANTRY_PLACED + player.getFaction() + "_" + round);
+            MessageHelper.sendMessageToChannel(
+                    event.getMessageChannel(),
+                    player.getRepresentation() + " has no eligible planet for the infantry.");
+            return;
+        }
+
+        String message = player.getRepresentation()
+                + ", please choose planets on which to place up to 4 infantry with _Power Word: Miracle_.";
+        String buttonPrefix = player.factionButtonChecker() + PLACE_INFANTRY + round + "_";
+        Button done = Buttons.red(player.factionButtonChecker() + FINISH_INFANTRY + round, "Done Placing Infantry");
+        List<Button> displayedButtons = planetButtons.size() < 25
+                ? new ArrayList<>(planetButtons)
+                : NewStuffHelper.buttonPagination(planetButtons, List.of(done), buttonPrefix, 25, 0, false);
+        if (planetButtons.size() < 25) {
+            displayedButtons.add(done);
+        }
+        MessageHelper.sendMessageToChannelWithButtons(event.getMessageChannel(), message, displayedButtons);
+    }
+
+    @ButtonHandler(PLACE_INFANTRY)
+    public static void placeMiracleInfantry(ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        if (game == null
+                || player == null
+                || !player.hasTech(MIRACLE)
+                || !player.getExhaustedTechs().contains(MIRACLE)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        String placementData = buttonID.substring(PLACE_INFANTRY.length());
+        int separator = placementData.indexOf('_');
+        if (separator < 1) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        int round;
+        try {
+            round = Integer.parseInt(placementData.substring(0, separator));
+        } catch (NumberFormatException e) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        String stateKey = INFANTRY_PLACED + player.getFaction() + "_" + round;
+        String placedValue = game.getStoredValue(stateKey);
+        if (round != game.getRound() || placedValue.isEmpty()) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        List<Button> planetButtons = getMiracleInfantryButtons(game, player, round);
+        String message = player.getRepresentation()
+                + ", please choose planets on which to place up to 4 infantry with _Power Word: Miracle_.";
+        String buttonPrefix = player.factionButtonChecker() + PLACE_INFANTRY + round + "_";
+        Button done = Buttons.red(player.factionButtonChecker() + FINISH_INFANTRY + round, "Done Placing Infantry");
+        String planetName = placementData.substring(separator + 1);
+        if (planetName.startsWith("page")) {
+            try {
+                int page = Integer.parseInt(planetName.substring("page".length()));
+                NewStuffHelper.sendOrEditButtons(
+                        event,
+                        event.getMessageChannel(),
+                        message,
+                        NewStuffHelper.buttonPagination(planetButtons, List.of(done), buttonPrefix, 25, page, false));
+            } catch (NumberFormatException e) {
+                ButtonHelper.deleteMessage(event);
+            }
+            return;
+        }
+
+        int placed;
+        try {
+            placed = Integer.parseInt(placedValue);
+        } catch (NumberFormatException e) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+        Planet planet = game.getUnitHolderFromPlanet(planetName);
+        if (placed >= 4) {
+            MessageHelper.sendMessageToChannel(
+                    event.getMessageChannel(),
+                    player.getRepresentation()
+                            + " has already placed all 4 infantry. Press **Done Placing Infantry** when finished.");
+            return;
+        }
+        if (planet == null
+                || !player.getPlanetsAllianceMode().contains(planetName)
+                || planet.isSpaceStation(game)
+                || planet.getTokenList().stream().anyMatch(token -> token.contains("dmz"))) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        AddUnitService.addUnits(
+                event, game.getTileFromPlanet(planetName), game, player.getColor(), "1 gf " + planetName);
+        game.setStoredValue(stateKey, String.valueOf(placed + 1));
+        MessageHelper.sendMessageToChannel(
+                event.getMessageChannel(),
+                player.getRepresentation() + " placed 1 infantry on " + Helper.getPlanetRepresentation(planetName, game)
+                        + " with _Power Word: Miracle_ (" + (placed + 1) + "/4)."
+                        + (placed == 3 ? " Press **Done Placing Infantry** when finished." : ""));
+    }
+
+    @ButtonHandler(FINISH_INFANTRY)
+    public static void finishMiracleInfantry(ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        if (game == null || player == null) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        try {
+            int round = Integer.parseInt(buttonID.substring(FINISH_INFANTRY.length()));
+            game.removeStoredValue(INFANTRY_PLACED + player.getFaction() + "_" + round);
+        } catch (NumberFormatException ignored) {
+            // The message is still safe to remove if an old or malformed completion button is pressed.
+        }
+        ButtonHelper.deleteMessage(event);
+    }
+
+    private static List<Button> getMiracleInfantryButtons(Game game, Player player, int round) {
+        List<Button> planetButtons = new ArrayList<>();
+        for (String planetName : player.getPlanetsAllianceMode()) {
+            Planet planet = game.getUnitHolderFromPlanet(planetName);
+            if (planet == null
+                    || planet.isSpaceStation(game)
+                    || planet.getTokenList().stream().anyMatch(token -> token.contains("dmz"))) {
+                continue;
+            }
+            planetButtons.add(Buttons.green(
+                    player.factionButtonChecker() + PLACE_INFANTRY + round + "_" + planetName,
+                    "Add 1 infantry to " + Helper.getPlanetRepresentation(planetName, game),
+                    UnitEmojis.infantry));
+        }
+        return planetButtons;
+    }
+
+    // Power Word: Plane Shift
+    public static boolean canUsePowerWordPlaneShift(Game game, Player player) {
+        return game != null
+                && player != null
+                && player == game.getActivePlayer()
+                && player.hasTechReady(PLANE_SHIFT)
+                && hasFourTechsMatchingPrimordial(player, PLANE_SHIFT)
+                && game.getTileMap().values().stream().anyMatch(ArcanumPrimordialTechHandler::isPlaneShiftSystem);
+    }
+
+    public static void resolvePowerWordPlaneShift(GenericInteractionCreateEvent event, Game game, Player player) {
+        if (game == null
+                || player == null
+                || player != game.getActivePlayer()
+                || !player.hasTech(PLANE_SHIFT)
+                || !player.getExhaustedTechs().contains(PLANE_SHIFT)
+                || !hasFourTechsMatchingPrimordial(player, PLANE_SHIFT)) {
+            return;
+        }
+
+        List<Button> buttons = getPlaneShiftSystemButtons(game, player);
+        if (buttons.isEmpty()) {
+            MessageHelper.sendMessageToChannel(
+                    event.getMessageChannel(), "No system without planets is available for _Power Word: Plane Shift_.");
+            return;
+        }
+
+        String prefix = player.factionButtonChecker() + PLANE_SHIFT_SELECT_SYSTEM;
+        game.setStoredValue(PLANE_SHIFT_PENDING, player.getFaction());
+        List<Button> displayedButtons =
+                buttons.size() <= 25 ? buttons : NewStuffHelper.buttonPagination(buttons, null, prefix, 25, 0, false);
+        MessageHelper.sendMessageToChannelWithButtons(
+                event.getMessageChannel(),
+                player.getRepresentation()
+                        + ", choose the planetless system to activate with _Power Word: Plane Shift_.\n"
+                        + "-# This tactical action does not spend or place a command token, and you ignore anomaly effects.",
+                displayedButtons);
+    }
+
+    @ButtonHandler(PLANE_SHIFT_SELECT_SYSTEM)
+    public static void selectPlaneShiftSystem(ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        if (game == null
+                || player == null
+                || player != game.getActivePlayer()
+                || !player.hasTech(PLANE_SHIFT)
+                || !player.getExhaustedTechs().contains(PLANE_SHIFT)
+                || !player.getFaction().equalsIgnoreCase(game.getStoredValue(PLANE_SHIFT_PENDING))
+                || !hasFourTechsMatchingPrimordial(player, PLANE_SHIFT)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        List<Button> buttons = getPlaneShiftSystemButtons(game, player);
+        String prefix = player.factionButtonChecker() + PLANE_SHIFT_SELECT_SYSTEM;
+        String message = player.getRepresentation()
+                + ", choose the planetless system to activate with _Power Word: Plane Shift_.\n"
+                + "-# This tactical action does not spend or place a command token, and you ignore anomaly effects.";
+        if (NewStuffHelper.checkAndHandlePaginationChange(
+                event, event.getMessageChannel(), buttons, message, prefix, buttonID)) {
+            return;
+        }
+
+        String position = buttonID.substring(PLANE_SHIFT_SELECT_SYSTEM.length());
+        Tile tile = game.getTileByPosition(position);
+        if (!isPlaneShiftSystem(tile)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        // The normal tactical-action handler handles every subsequent step; its activation-cost hook recognizes
+        // this scoped state and skips only Plane Shift's command-token placement.
+        game.removeStoredValue(PLANE_SHIFT_PENDING);
+        game.setStoredValue(PLANE_SHIFT_PLAYER, player.getFaction());
+        game.setStoredValue(PLANE_SHIFT_SYSTEM, position);
+        ButtonHelperTacticalAction.selectActiveSystem(player, game, event, "ringTile_" + position);
+        MessageHelper.sendMessageToChannel(
+                player.getCorrectChannel(),
+                player.getRepresentationUnfogged()
+                        + " activated "
+                        + tile.getRepresentationForButtons(game, player)
+                        + " with _Power Word: Plane Shift_ without spending a command token. Anomaly effects are ignored for this tactical action.");
+        ButtonHelper.deleteMessage(event);
+    }
+
+    public static boolean planeShiftIgnoresAnomalies(Game game, Player player) {
+        String activeSystem = game == null ? null : game.getActiveSystem();
+        return game != null
+                && player != null
+                && player.getFaction().equalsIgnoreCase(game.getStoredValue(PLANE_SHIFT_PLAYER))
+                && activeSystem != null
+                && activeSystem.equalsIgnoreCase(game.getStoredValue(PLANE_SHIFT_SYSTEM));
+    }
+
+    public static void clearPowerWordPlaneShift(Game game) {
+        if (game != null) {
+            game.removeStoredValue(PLANE_SHIFT_PENDING);
+            game.removeStoredValue(PLANE_SHIFT_PLAYER);
+            game.removeStoredValue(PLANE_SHIFT_SYSTEM);
+        }
+    }
+
+    private static List<Button> getPlaneShiftSystemButtons(Game game, Player player) {
+        List<Button> buttons = new ArrayList<>();
+        for (Tile tile : game.getTileMap().values()) {
+            if (isPlaneShiftSystem(tile)) {
+                buttons.add(Buttons.green(
+                        player.factionButtonChecker() + PLANE_SHIFT_SELECT_SYSTEM + tile.getPosition(),
+                        tile.getRepresentationForButtons(game, player),
+                        tile.getTileEmoji(player)));
+            }
+        }
+        return buttons;
+    }
+
+    private static boolean isPlaneShiftSystem(Tile tile) {
+        return tile != null
+                && tile.getTileModel() != null
+                && !tile.getTileModel().isHyperlane()
+                && !"silver_flame".equalsIgnoreCase(tile.getTileID())
+                && tile.getPlanetUnitHolders().isEmpty();
+    }
+
+    // Power Word: Disintegrate
+    public static List<Button> getDisintegrateCombatButtons(
+            Player player, Player opponent, Tile tile, UnitHolder combatHolder) {
+        if (player == null
+                || opponent == null
+                || tile == null
+                || combatHolder == null
+                || !player.hasTech(DISINTEGRATE)
+                || !hasFourTechsMatchingPrimordial(player, DISINTEGRATE)) {
+            return List.of();
+        }
+
+        String payload = tile.getPosition() + "|" + combatHolder.getName() + "|" + opponent.getFaction();
+        List<Button> buttons = new ArrayList<>();
+        buttons.add(Buttons.red(
+                player.factionButtonChecker() + DISINTEGRATE_HIT + payload, "Produce 1 Hit", TechEmojis.WarfareTech));
+        if (player.hasTechReady(DISINTEGRATE)) {
+            buttons.add(Buttons.red(
+                    player.factionButtonChecker() + DISINTEGRATE_DESTROY + payload,
+                    "Exhaust Power Word: Disintegrate",
+                    TechEmojis.WarfareTech));
+        }
+        return buttons;
+    }
+
+    @ButtonHandler(DISINTEGRATE_HIT)
+    public static void produceDisintegrateHit(ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        DisintegrateCombat combat = getDisintegrateCombat(game, player, buttonID, DISINTEGRATE_HIT);
+        if (combat == null || !player.hasTech(DISINTEGRATE) || !hasFourTechsMatchingPrimordial(player, DISINTEGRATE)) {
+            ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
+            return;
+        }
+
+        ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
+        boolean spaceCombat = "space".equals(combat.holder().getName());
+        List<Button> buttons = new ArrayList<>();
+        if (spaceCombat) {
+            buttons.add(Buttons.green(
+                    combat.opponent().factionButtonChecker()
+                            + "autoAssignSpaceHits_"
+                            + combat.tile().getPosition()
+                            + "_1",
+                    "Auto-assign 1 Hit"));
+            buttons.add(Buttons.red(
+                    combat.opponent().factionButtonChecker()
+                            + "getDamageButtons_"
+                            + combat.tile().getPosition()
+                            + "deleteThis_spacecombat",
+                    "Manually Assign 1 Hit"));
+        } else {
+            buttons.add(Buttons.green(
+                    combat.opponent().factionButtonChecker()
+                            + "autoAssignGroundHits_"
+                            + combat.holder().getName()
+                            + "_1",
+                    "Auto-assign 1 Hit"));
+            buttons.add(Buttons.red(
+                    combat.opponent().factionButtonChecker()
+                            + "getDamageButtons_"
+                            + combat.tile().getPosition()
+                            + "deleteThis_groundcombat",
+                    "Manually Assign 1 Hit"));
+        }
+        MessageHelper.sendMessageToChannelWithButtons(
+                event.getMessageChannel(),
+                combat.opponent().getRepresentationNoPing() + ", assign 1 hit from _Power Word: Disintegrate_.",
+                buttons);
+    }
+
+    @ButtonHandler(DISINTEGRATE_DESTROY)
+    public static void exhaustDisintegrateToDestroyUnit(
+            ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        DisintegrateCombat combat = getDisintegrateCombat(game, player, buttonID, DISINTEGRATE_DESTROY);
+        if (combat == null
+                || !player.hasTechReady(DISINTEGRATE)
+                || !hasFourTechsMatchingPrimordial(player, DISINTEGRATE)) {
+            ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
+            return;
+        }
+
+        List<Button> buttons = new ArrayList<>();
+        for (UnitKey unitKey : combat.holder().getUnitKeysForPlayer(combat.opponent())) {
+            UnitModel unit = combat.opponent().getUnitFromUnitKey(unitKey);
+            if (!isDisintegrateCombatUnit(combat.holder(), unit)) {
+                continue;
+            }
+            for (UnitState state : UnitState.values()) {
+                if (combat.holder().getUnitCountForState(unitKey, state) < 1) {
+                    continue;
+                }
+                String stateLabel = state == UnitState.none ? "" : state.humanDescr() + " ";
+                buttons.add(Buttons.red(
+                        combat.opponent().factionButtonChecker()
+                                + DISINTEGRATE_DESTROY_UNIT
+                                + combat.tile().getPosition()
+                                + "|"
+                                + combat.holder().getName()
+                                + "|"
+                                + player.getFaction()
+                                + "|"
+                                + unitKey.unitType().value
+                                + "|"
+                                + state.name(),
+                        "Destroy " + stateLabel + unitKey.humanReadableName()));
+            }
+        }
+        if (buttons.isEmpty()) {
+            ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
+            return;
+        }
+
+        player.exhaustTech(DISINTEGRATE);
+        ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
+        MessageHelper.sendMessageToChannelWithButtons(
+                event.getMessageChannel(),
+                combat.opponent().getRepresentationNoPing()
+                        + ", choose 1 participating unit to destroy due to _Power Word: Disintegrate_.",
+                buttons);
+    }
+
+    @ButtonHandler(DISINTEGRATE_DESTROY_UNIT)
+    public static void destroyDisintegrateUnit(
+            ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        String[] payload =
+                buttonID.substring(DISINTEGRATE_DESTROY_UNIT.length()).split("\\|", 5);
+        Tile tile = payload.length == 5 ? game.getTileByPosition(payload[0]) : null;
+        UnitHolder holder = tile == null || payload.length != 5
+                ? null
+                : tile.getUnitHolders().get(payload[1]);
+        Player techOwner = payload.length == 5 ? game.getPlayerFromColorOrFaction(payload[2]) : null;
+        UnitType unitType = payload.length == 5 ? Units.findUnitType(payload[3]) : null;
+        UnitState state = payload.length == 5 ? Units.findUnitState(payload[4]) : null;
+        if (tile == null
+                || holder == null
+                || techOwner == null
+                || !techOwner.hasTech(DISINTEGRATE)
+                || !hasFourTechsMatchingPrimordial(techOwner, DISINTEGRATE)
+                || unitType == null
+                || state == null
+                || !isDisintegrateCombat(game, techOwner, player, tile, holder)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        UnitKey unitKey = holder.getUnitKeysForPlayer(player).stream()
+                .filter(key -> key.unitType() == unitType)
+                .findFirst()
+                .orElse(null);
+        UnitModel unit = unitKey == null ? null : player.getUnitFromUnitKey(unitKey);
+        if (unitKey == null
+                || !isDisintegrateCombatUnit(holder, unit)
+                || holder.getUnitCountForState(unitKey, state) < 1) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        DestroyUnitService.destroyUnit(event, tile, game, new ParsedUnit(unitKey, 1, holder.getName()), true, state);
+        ButtonHelper.deleteMessage(event);
+        MessageHelper.sendMessageToChannel(
+                event.getMessageChannel(),
+                player.getRepresentationNoPing() + " destroyed 1 "
+                        + unitKey.humanReadableName().toLowerCase() + " due to _Power Word: Disintegrate_.");
+    }
+
+    private static DisintegrateCombat getDisintegrateCombat(
+            Game game, Player player, String buttonID, String buttonPrefix) {
+        String[] payload = buttonID.substring(buttonPrefix.length()).split("\\|", 3);
+        Tile tile = payload.length == 3 ? game.getTileByPosition(payload[0]) : null;
+        UnitHolder holder = tile == null || payload.length != 3
+                ? null
+                : tile.getUnitHolders().get(payload[1]);
+        Player opponent = payload.length == 3 ? game.getPlayerFromColorOrFaction(payload[2]) : null;
+        return isDisintegrateCombat(game, player, opponent, tile, holder)
+                ? new DisintegrateCombat(tile, holder, opponent)
+                : null;
+    }
+
+    private static boolean isDisintegrateCombat(
+            Game game, Player player, Player opponent, Tile tile, UnitHolder holder) {
+        StartCombatService.CurrentCombat combat = StartCombatService.getCurrentCombat(game);
+        return combat != null
+                && player != null
+                && opponent != null
+                && player != opponent
+                && tile != null
+                && holder != null
+                && combat.factions().contains(player.getFaction())
+                && combat.factions().contains(opponent.getFaction())
+                && (combat.tilePosition() == null || combat.tilePosition().equals(tile.getPosition()))
+                && (combat.unitHolderName() == null || combat.unitHolderName().equals(holder.getName()))
+                && holder.getUnitKeysForPlayer(player).stream()
+                        .map(player::getUnitFromUnitKey)
+                        .anyMatch(unit -> isDisintegrateCombatUnit(holder, unit))
+                && holder.getUnitKeysForPlayer(opponent).stream()
+                        .map(opponent::getUnitFromUnitKey)
+                        .anyMatch(unit -> isDisintegrateCombatUnit(holder, unit));
+    }
+
+    private static boolean isDisintegrateCombatUnit(UnitHolder holder, UnitModel unit) {
+        return unit != null && ("space".equals(holder.getName()) ? unit.getIsShip() : unit.getIsGroundForce());
+    }
+
+    private record DisintegrateCombat(Tile tile, UnitHolder holder, Player opponent) {}
+
+    // Power Word: Fabricate station ability
+    public static void offerFabricateStationProduction(GenericInteractionCreateEvent event, Game game, Player player) {
+        if (!canUseFabricateStation(game, player)) {
+            return;
+        }
+        if (!game.getStoredValue("producedUnitCostFor" + player.getFaction()).isEmpty()) {
+            MessageHelper.sendMessageToChannel(
+                    event.getMessageChannel(),
+                    player.getRepresentation()
+                            + " must finish paying for their existing production before using **Mass Production**.");
+            return;
+        }
+        // Completed productions intentionally retain this list for their summary; Fabricate starts a new build.
+        player.resetProducedUnits();
+
+        List<Button> sourceButtons = getFabricateSourceButtons(game, player);
+        if (sourceButtons.isEmpty()) {
+            MessageHelper.sendMessageToChannel(
+                    event.getMessageChannel(),
+                    player.getRepresentation() + " has no system with PRODUCTION available for **Mass Production**.");
+            return;
+        }
+
+        String message = player.getRepresentation()
+                + ", please choose the system whose PRODUCTION you will use for **Mass Production**.";
+        String buttonPrefix = player.factionButtonChecker() + FABRICATE_SELECT_SOURCE;
+        MessageHelper.sendMessageToChannelWithButtons(
+                event.getMessageChannel(),
+                message,
+                sourceButtons.size() < 25
+                        ? sourceButtons
+                        : NewStuffHelper.buttonPagination(sourceButtons, null, buttonPrefix, 25, 0, false));
+    }
+
+    @ButtonHandler(FABRICATE_SELECT_SOURCE)
+    public static void selectFabricateStationSource(
+            ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        if (!canUseFabricateStation(game, player)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        List<Button> sourceButtons = getFabricateSourceButtons(game, player);
+        String message = player.getRepresentation()
+                + ", please choose the system whose PRODUCTION you will use for **Mass Production**.";
+        String buttonPrefix = player.factionButtonChecker() + FABRICATE_SELECT_SOURCE;
+        String payload = buttonID.substring(FABRICATE_SELECT_SOURCE.length());
+        if (payload.startsWith("page")) {
+            sendFabricatePage(event, message, sourceButtons, buttonPrefix, payload.substring("page".length()), null);
+            return;
+        }
+
+        Tile source = game.getTileByPosition(payload);
+        if (!isFabricateSource(game, player, source)
+                || getFabricateSystemButtons(game, player, source).isEmpty()) {
+            ButtonHelper.deleteMessage(event);
+            MessageHelper.sendMessageToChannel(
+                    event.getMessageChannel(),
+                    player.getRepresentation()
+                            + " no longer has an eligible **Mass Production** source or destination.");
+            return;
+        }
+
+        ButtonHelper.deleteMessage(event);
+        sendFabricateSystemButtons(event, game, player, source);
+    }
+
+    @ButtonHandler(FABRICATE_SELECT_SYSTEM)
+    public static void selectFabricateStationSystem(
+            ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        if (!canUseFabricateStation(game, player)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        String payload = buttonID.substring(FABRICATE_SELECT_SYSTEM.length());
+        String[] systems = payload.split("\\|", 2);
+        Tile source = systems.length == 2 ? game.getTileByPosition(systems[0]) : null;
+        if (!isFabricateSource(game, player, source)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        List<Button> systemButtons = getFabricateSystemButtons(game, player, source);
+        String message = getFabricateSystemMessage(game, player, source);
+        String buttonPrefix = player.factionButtonChecker() + FABRICATE_SELECT_SYSTEM + source.getPosition() + "|";
+        String selection = systems[1];
+        if (selection.startsWith("page")) {
+            sendFabricatePage(event, message, systemButtons, buttonPrefix, selection.substring("page".length()), null);
+            return;
+        }
+        if ("choose".equals(selection)) {
+            ButtonHelper.deleteMessage(event);
+            sendFabricateSystemButtons(event, game, player, source);
+            return;
+        }
+
+        Tile destination = game.getTileByPosition(selection);
+        if (!isFabricateDestination(game, player, destination)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        ButtonHelper.deleteMessage(event);
+        sendFabricateProductionButtons(event, game, player, source, destination, 0);
+    }
+
+    @ButtonHandler(FABRICATE_PLACE_UNIT)
+    public static void placeFabricateStationUnit(
+            ButtonInteractionEvent event, Game game, Player player, String buttonID) {
+        if (!canUseFabricateStation(game, player)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+
+        String[] placement = buttonID.substring(FABRICATE_PLACE_UNIT.length()).split("\\|", 3);
+        Tile source = placement.length == 3 ? game.getTileByPosition(placement[0]) : null;
+        Tile destination = placement.length == 3 ? game.getTileByPosition(placement[1]) : null;
+        if (!isFabricateSource(game, player, source) || !isFabricateDestination(game, player, destination)) {
+            ButtonHelper.deleteMessage(event);
+            return;
+        }
+        if (placement[2].startsWith("page")) {
+            try {
+                sendFabricateProductionButtons(
+                        event,
+                        game,
+                        player,
+                        source,
+                        destination,
+                        Integer.parseInt(placement[2].substring("page".length())));
+            } catch (NumberFormatException e) {
+                ButtonHelper.deleteMessage(event);
+            }
+            return;
+        }
+
+        String standardPayload = placement[2].startsWith("_") ? placement[2].substring(1) : placement[2];
+        int amount = getFabricateProducedUnitAmount(standardPayload);
+        if (!isFabricatePlacementForDestination(game, destination, standardPayload)
+                || amount < 1
+                || getFabricateProducedUnitCount(player) + amount > getFabricateProductionLimit(game, player, source)) {
+            MessageHelper.sendMessageToChannel(
+                    event.getMessageChannel(),
+                    player.getRepresentation() + " cannot exceed the source system's PRODUCTION value of "
+                            + getFabricateProductionLimit(game, player, source) + ".");
+            return;
+        }
+
+        ButtonHelperModifyUnits.genericPlaceUnit("place_" + standardPayload, event, game, player);
+    }
+
+    private static void sendFabricateSystemButtons(
+            GenericInteractionCreateEvent event, Game game, Player player, Tile source) {
+        List<Button> buttons = getFabricateSystemButtons(game, player, source);
+        String message = getFabricateSystemMessage(game, player, source);
+        String buttonPrefix = player.factionButtonChecker() + FABRICATE_SELECT_SYSTEM + source.getPosition() + "|";
+        MessageHelper.sendMessageToChannelWithButtons(
+                event.getMessageChannel(),
+                message,
+                buttons.size() < 25
+                        ? buttons
+                        : NewStuffHelper.buttonPagination(buttons, null, buttonPrefix, 25, 0, false));
+    }
+
+    private static void sendFabricateProductionButtons(
+            GenericInteractionCreateEvent event, Game game, Player player, Tile source, Tile destination, int page) {
+        Map<String, Integer> producedUnits = new HashMap<>(player.getCurrentProducedUnits());
+        String placePrefix = FABRICATE_PLACE_UNIT + source.getPosition() + "|" + destination.getPosition() + "|";
+        List<Button> productionButtons =
+                Helper.getPlaceUnitButtons(event, player, game, destination, "fabricateStation", placePrefix);
+        player.resetProducedUnits();
+        producedUnits.forEach(player::setProducedUnit);
+
+        List<Button> extraButtons = List.of(
+                Buttons.blue(
+                        player.factionButtonChecker() + FABRICATE_SELECT_SYSTEM + source.getPosition() + "|choose",
+                        "Choose Another System"),
+                Buttons.red(
+                        player.factionButtonChecker() + "deleteButtons_" + source.getPosition(),
+                        "Done Producing Units"),
+                Buttons.gray(player.factionButtonChecker() + "resetProducedThings", "Reset Build"));
+        String message = player.getRepresentation() + ", use the normal production buttons to produce in "
+                + destination.getRepresentationForButtons(game, player) + ". Your shared **Mass Production** limit is "
+                + getFabricateProductionLimit(game, player, source) + " from "
+                + source.getRepresentationForButtons(game, player) + ".";
+        String buttonPrefix = player.factionButtonChecker() + placePrefix;
+        List<Button> buttons = productionButtons.size() + extraButtons.size() <= 25
+                ? appendFabricateButtons(productionButtons, extraButtons)
+                : NewStuffHelper.buttonPagination(productionButtons, extraButtons, buttonPrefix, 25, page, false);
+        NewStuffHelper.sendOrEditButtons(event, event.getMessageChannel(), message, buttons);
+    }
+
+    private static List<Button> getFabricateSystemButtons(Game game, Player player, Tile source) {
+        List<Button> buttons = new ArrayList<>();
+        for (Tile tile : game.getTileMap().values()) {
+            if (isFabricateDestination(game, player, tile)) {
+                buttons.add(Buttons.green(
+                        player.factionButtonChecker() + FABRICATE_SELECT_SYSTEM + source.getPosition() + "|"
+                                + tile.getPosition(),
+                        tile.getRepresentationForButtons(game, player)));
+            }
+        }
+        return buttons;
+    }
+
+    private static String getFabricateSystemMessage(Game game, Player player, Tile source) {
+        return player.getRepresentation() + ", choose a system in which to use **Mass Production** from "
+                + source.getRepresentationForButtons(game, player)
+                + ". The system must contain your ships and no other player's units.";
+    }
+
+    private static boolean isFabricateSource(Game game, Player player, Tile tile) {
+        return tile != null && getFabricateProductionLimit(game, player, tile) > 0;
+    }
+
+    private static int getFabricateProductionLimit(Game game, Player player, Tile source) {
+        int production = Helper.getProductionValue(player, game, source, false);
+        if (player.getSpentThingsThisWindow().contains("warmachine")) {
+            production += 4;
+        }
+        for (String spent : player.getSpentThingsThisWindow()) {
+            if (spent.startsWith("liquidation")
+                    && !spent.replace("liquidation", "").isEmpty()) {
+                production -= Integer.parseInt(spent.replace("liquidation", ""));
+            }
+        }
+        if (game.playerHasLeaderUnlockedOrAlliance(player, "cabalcommander")) {
+            production += 2;
+        }
+        return Math.max(0, production);
+    }
+
+    private static int getFabricateProducedUnitCount(Player player) {
+        return player.getCurrentProducedUnits().values().stream()
+                .mapToInt(Integer::intValue)
+                .sum();
+    }
+
+    private static int getFabricateProducedUnitAmount(String payload) {
+        int separator = payload.indexOf('_');
+        if (separator < 1) {
+            return 0;
+        }
+        String unit = payload.substring(0, separator);
+        return "2ff".equals(unit) || "2destroyer".equals(unit) || "2gf".equals(unit) ? 2 : 1;
+    }
+
+    private static boolean isFabricatePlacementForDestination(Game game, Tile destination, String payload) {
+        int separator = payload.indexOf('_');
+        if (separator < 1) {
+            return false;
+        }
+        String location = payload.substring(separator + 1);
+        if (location.startsWith("space")) {
+            return destination.getPosition().equals(location.substring("space".length()));
+        }
+        if (destination.getPosition().equals(location)) {
+            return true;
+        }
+        Tile planetTile = game.getTileFromPlanet(location);
+        return planetTile == destination;
+    }
+
+    private static List<Button> appendFabricateButtons(List<Button> buttons, List<Button> extraButtons) {
+        List<Button> allButtons = new ArrayList<>(buttons);
+        allButtons.addAll(extraButtons);
+        return allButtons;
+    }
+
+    private static boolean canUseFabricateStation(Game game, Player player) {
+        return game != null
+                && player != null
+                && player.hasTech(FABRICATE_TECH)
+                && player.getPlanets().contains(FABRICATE_STATION)
+                && player.getExhaustedPlanetsAbilities().contains(FABRICATE_STATION);
+    }
+
+    private static List<Button> getFabricateSourceButtons(Game game, Player player) {
+        List<Button> buttons = new ArrayList<>();
+        for (Tile tile : game.getTileMap().values()) {
+            int production = getFabricateProductionLimit(game, player, tile);
+            if (production > 0) {
+                buttons.add(Buttons.green(
+                        player.factionButtonChecker() + FABRICATE_SELECT_SOURCE + tile.getPosition(),
+                        tile.getRepresentationForButtons(game, player) + " (PRODUCTION " + production + ")"));
+            }
+        }
+        return buttons;
+    }
+
+    private static boolean isFabricateDestination(Game game, Player player, Tile tile) {
+        return tile != null
+                && FoWHelper.playerHasShipsInSystem(player, tile)
+                && !FoWHelper.otherPlayersHaveUnitsInSystem(player, tile, game);
+    }
+
+    private static void sendFabricatePage(
+            ButtonInteractionEvent event,
+            String message,
+            List<Button> buttons,
+            String buttonPrefix,
+            String pageValue,
+            Button extraButton) {
+        try {
+            int page = Integer.parseInt(pageValue);
+            List<Button> extraButtons = extraButton == null ? null : List.of(extraButton);
+            NewStuffHelper.sendOrEditButtons(
+                    event,
+                    event.getMessageChannel(),
+                    message,
+                    NewStuffHelper.buttonPagination(buttons, extraButtons, buttonPrefix, 25, page, false));
+        } catch (NumberFormatException e) {
+            ButtonHelper.deleteMessage(event);
+        }
+    }
+}
diff --git a/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumTechHandler.java b/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumTechHandler.java
index 5e29280cd7..b295faa533 100644
--- a/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumTechHandler.java
+++ b/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumTechHandler.java
@@ -3,7 +3,6 @@
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 import lombok.experimental.UtilityClass;
 import net.dv8tion.jda.api.components.buttons.Button;
@@ -12,26 +11,18 @@
 import ti4.discord.interactions.buttons.Buttons;
 import ti4.discord.interactions.routing.ButtonHandler;
 import ti4.game.Game;
-import ti4.game.Planet;
 import ti4.game.Player;
 import ti4.game.Tile;
-import ti4.helpers.ActionCardHelper;
 import ti4.helpers.ButtonHelper;
-import ti4.helpers.ComponentActionHelper;
 import ti4.helpers.Constants;
 import ti4.helpers.FoWHelper;
-import ti4.helpers.Helper;
 import ti4.helpers.NewStuffHelper;
 import ti4.image.Mapper;
 import ti4.message.MessageHelper;
 import ti4.model.ExploreModel;
-import ti4.model.TechnologyModel;
 import ti4.model.UnitModel;
 import ti4.service.combat.StartCombatService;
-import ti4.service.emoji.CardEmojis;
 import ti4.service.emoji.TechEmojis;
-import ti4.service.emoji.UnitEmojis;
-import ti4.service.unit.AddUnitService;
 
 @UtilityClass
 public class ArcanumTechHandler {
@@ -40,18 +31,8 @@ public class ArcanumTechHandler {
     private static final String SHUFFLE_PURGED_EXPLORE = "shuffleSealOfRevelation_";
     private static final String USE_SIGIL_OF_TRANSMUTATION = "useSigilOfTransmutation";
     private static final String SIGIL_OF_TRANSMUTATION_TILE = "sigilOfTransmutationTile_";
-    private static final List<String> PRIMORDIAL_TECHS =
-            List.of("tharcanumpmy", "tharcanumpmg", "tharcanumpmr", "tharcanumpmb");
     private static final List<String> EXPLORE_TYPES =
             List.of(Constants.CULTURAL, Constants.HAZARDOUS, Constants.INDUSTRIAL, Constants.FRONTIER);
-    private static final String MIRACLE = "tharcanumpmg";
-    private static final String DISCARD_AC = "miracleAcDiscard";
-    private static final String GAIN_CC = "miracleGainCC";
-    private static final String PLACE_INF = "miraclePlaceFourInf";
-    private static final String SELECT_AC = "miracleSelectAcToDiscard_";
-    private static final String PLACE_INFANTRY = "miraclePlaceInfantry_";
-    private static final String FINISH_INFANTRY = "miracleFinishInfantry_";
-    private static final String INFANTRY_PLACED = "miracleInfantryPlaced_";
 
     // Seal of Revelation
     public static void resolveSealOfRevelation(GenericInteractionCreateEvent event, Game game, Player player) {
@@ -176,41 +157,6 @@ private static void offerPlanetExplorationButtons(GenericInteractionCreateEvent
                 buttons);
     }
 
-    // Forbidden Knowledge
-    public static boolean hasFourTechsMatchingPrimordial(Player player) {
-        if (player == null) {
-            return false;
-        }
-
-        TechnologyModel.TechnologyType primordialType = null;
-        for (String primordialTech : PRIMORDIAL_TECHS) {
-            if (!player.hasTech(primordialTech)) {
-                continue;
-            }
-
-            TechnologyModel techModel = Mapper.getTech(primordialTech);
-            if (techModel != null) {
-                primordialType = techModel.getFirstType();
-            }
-            break;
-        }
-        if (primordialType == null) {
-            return false;
-        }
-
-        int matchingTechs = 0;
-        for (String tech : player.getTechs()) {
-            if (PRIMORDIAL_TECHS.contains(tech)) {
-                continue;
-            }
-            TechnologyModel techModel = Mapper.getTech(tech);
-            if (techModel != null && techModel.getTypes().contains(primordialType)) {
-                matchingTechs++;
-            }
-        }
-        return matchingTechs >= 4;
-    }
-
     // Sigil of Transmutation
     public static void offerSigilOfTransmutation(ButtonInteractionEvent event, Game game, Player player, Tile tile) {
         if (event == null
@@ -263,7 +209,6 @@ public static void useSigilOfTransmutation(ButtonInteractionEvent event, Game ga
         if (!spaceCannonPromptAlreadyAvailable && FoWHelper.otherPlayersHaveShipsInSystem(player, tile, game)) {
             StartCombatService.sendSpaceCannonButtonsToThread(event.getMessageChannel(), game, player, tile);
         }
-        ComponentActionHelper.serveNextComponentActionButtons(event, game, player);
         ButtonHelper.deleteMessage(event);
     }
 
@@ -313,247 +258,4 @@ public static void resetSigilOfTransmutationForNewDestination(Game game, Player
             player.refreshTech(SIGIL_OF_TRANSMUTATION);
         }
     }
-
-    // Power Word: Miracle
-    public static void resolvePowerWordMiracle(GenericInteractionCreateEvent event, Game game, Player player) {
-        if (game == null
-                || player == null
-                || !player.hasTech(MIRACLE)
-                || !player.getExhaustedTechs().contains(MIRACLE)
-                || !hasFourTechsMatchingPrimordial(player)) {
-            return;
-        }
-        ComponentActionHelper.serveNextComponentActionButtons(event, game, player);
-
-        List<Button> buttons = new ArrayList<>();
-        buttons.add(Buttons.green(
-                player.factionButtonChecker() + DISCARD_AC, "Discard 1 AC and Draw 2", CardEmojis.getACEmoji(game)));
-        buttons.add(Buttons.green(player.factionButtonChecker() + GAIN_CC, "Gain 1 Command Token"));
-        buttons.add(Buttons.green(player.factionButtonChecker() + PLACE_INF, "Place 4 Infantry", UnitEmojis.infantry));
-
-        MessageHelper.sendMessageToChannelWithButtons(
-                event.getMessageChannel(),
-                player.getRepresentation() + ", please choose an effect for _Power Word: Miracle_.",
-                buttons);
-    }
-
-    @ButtonHandler(DISCARD_AC)
-    public static void getAcDiscardButtons(ButtonInteractionEvent event, Game game, Player player) {
-        if (game == null
-                || player == null
-                || !player.hasTech(MIRACLE)
-                || !player.getExhaustedTechs().contains(MIRACLE)
-                || !hasFourTechsMatchingPrimordial(player)) {
-            return;
-        }
-        ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
-
-        List<Button> discardButtons = new ArrayList<>();
-
-        for (Map.Entry<String, Integer> actionCard : player.getActionCards().entrySet()) {
-            discardButtons.add(Buttons.blue(
-                    player.factionButtonChecker() + SELECT_AC + actionCard.getValue(),
-                    "(" + actionCard.getValue() + ") "
-                            + Mapper.getActionCard(actionCard.getKey()).getName(),
-                    CardEmojis.getACEmoji(game)));
-        }
-
-        MessageHelper.sendMessageToChannelWithButtons(
-                player.getCardsInfoThread(),
-                player.getRepresentation() + ", please choose an action card to discard.",
-                discardButtons);
-    }
-
-    @ButtonHandler(SELECT_AC)
-    public static void resolveMiracleAcDiscard(
-            ButtonInteractionEvent event, Game game, Player player, String buttonID) {
-        if (player == null || game == null || !player.hasTech(MIRACLE) || !hasFourTechsMatchingPrimordial(player)) {
-            return;
-        }
-
-        int handIndex;
-
-        try {
-            handIndex = Integer.parseInt(buttonID.substring(SELECT_AC.length()));
-        } catch (NumberFormatException e) {
-            ButtonHelper.deleteMessage(event);
-            return;
-        }
-
-        if (!player.getExhaustedTechs().contains("tharcanumpmg")
-                || !player.getActionCards().containsValue(handIndex)) {
-            ButtonHelper.deleteMessage(event);
-            return;
-        }
-
-        ActionCardHelper.discardAC(event, game, player, handIndex);
-        ActionCardHelper.drawActionCards(player, 2);
-        ButtonHelper.deleteMessage(event);
-    }
-
-    @ButtonHandler(GAIN_CC)
-    public static void resolveMiracleCCGain(ButtonInteractionEvent event, Game game, Player player) {
-        if (player == null || game == null || !player.hasTech(MIRACLE) || !hasFourTechsMatchingPrimordial(player)) {
-            return;
-        }
-        ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
-
-        MessageHelper.sendMessageToChannelWithButtons(
-                event.getMessageChannel(),
-                player.getRepresentation() + ", please choose where to gain 1 command token.",
-                ButtonHelper.getGainCCButtons(player));
-    }
-
-    @ButtonHandler(PLACE_INF)
-    public static void getMiracleInfantryPlacementButtons(ButtonInteractionEvent event, Game game, Player player) {
-        if (game == null
-                || player == null
-                || !player.hasTech(MIRACLE)
-                || !player.getExhaustedTechs().contains(MIRACLE)
-                || !hasFourTechsMatchingPrimordial(player)) {
-            return;
-        }
-
-        ButtonHelper.deleteButtonAndDeleteMessageIfEmpty(event);
-        int round = game.getRound();
-        game.setStoredValue(INFANTRY_PLACED + player.getFaction() + "_" + round, "0");
-        List<Button> planetButtons = getMiracleInfantryButtons(game, player, round);
-        if (planetButtons.isEmpty()) {
-            game.removeStoredValue(INFANTRY_PLACED + player.getFaction() + "_" + round);
-            MessageHelper.sendMessageToChannel(
-                    event.getMessageChannel(),
-                    player.getRepresentation() + " has no eligible planet for the infantry.");
-            return;
-        }
-
-        String message = player.getRepresentation()
-                + ", please choose planets on which to place up to 4 infantry with _Power Word: Miracle_.";
-        String buttonPrefix = player.factionButtonChecker() + PLACE_INFANTRY + round + "_";
-        Button done = Buttons.red(player.factionButtonChecker() + FINISH_INFANTRY + round, "Done Placing Infantry");
-        List<Button> displayedButtons = planetButtons.size() < 25
-                ? new ArrayList<>(planetButtons)
-                : NewStuffHelper.buttonPagination(planetButtons, List.of(done), buttonPrefix, 25, 0, false);
-        if (planetButtons.size() < 25) {
-            displayedButtons.add(done);
-        }
-        MessageHelper.sendMessageToChannelWithButtons(event.getMessageChannel(), message, displayedButtons);
-    }
-
-    @ButtonHandler(PLACE_INFANTRY)
-    public static void placeMiracleInfantry(ButtonInteractionEvent event, Game game, Player player, String buttonID) {
-        if (game == null
-                || player == null
-                || !player.hasTech(MIRACLE)
-                || !player.getExhaustedTechs().contains(MIRACLE)) {
-            ButtonHelper.deleteMessage(event);
-            return;
-        }
-
-        String placementData = buttonID.substring(PLACE_INFANTRY.length());
-        int separator = placementData.indexOf('_');
-        if (separator < 1) {
-            ButtonHelper.deleteMessage(event);
-            return;
-        }
-
-        int round;
-        try {
-            round = Integer.parseInt(placementData.substring(0, separator));
-        } catch (NumberFormatException e) {
-            ButtonHelper.deleteMessage(event);
-            return;
-        }
-
-        String stateKey = INFANTRY_PLACED + player.getFaction() + "_" + round;
-        String placedValue = game.getStoredValue(stateKey);
-        if (round != game.getRound() || placedValue.isEmpty()) {
-            ButtonHelper.deleteMessage(event);
-            return;
-        }
-
-        List<Button> planetButtons = getMiracleInfantryButtons(game, player, round);
-        String message = player.getRepresentation()
-                + ", please choose planets on which to place up to 4 infantry with _Power Word: Miracle_.";
-        String buttonPrefix = player.factionButtonChecker() + PLACE_INFANTRY + round + "_";
-        Button done = Buttons.red(player.factionButtonChecker() + FINISH_INFANTRY + round, "Done Placing Infantry");
-        String planetName = placementData.substring(separator + 1);
-        if (planetName.startsWith("page")) {
-            try {
-                int page = Integer.parseInt(planetName.substring("page".length()));
-                NewStuffHelper.sendOrEditButtons(
-                        event,
-                        event.getMessageChannel(),
-                        message,
-                        NewStuffHelper.buttonPagination(planetButtons, List.of(done), buttonPrefix, 25, page, false));
-            } catch (NumberFormatException e) {
-                ButtonHelper.deleteMessage(event);
-            }
-            return;
-        }
-
-        int placed;
-        try {
-            placed = Integer.parseInt(placedValue);
-        } catch (NumberFormatException e) {
-            ButtonHelper.deleteMessage(event);
-            return;
-        }
-        Planet planet = game.getUnitHolderFromPlanet(planetName);
-        if (placed >= 4) {
-            MessageHelper.sendMessageToChannel(
-                    event.getMessageChannel(),
-                    player.getRepresentation()
-                            + " has already placed all 4 infantry. Press **Done Placing Infantry** when finished.");
-            return;
-        }
-        if (planet == null
-                || !player.getPlanetsAllianceMode().contains(planetName)
-                || planet.isSpaceStation(game)
-                || planet.getTokenList().stream().anyMatch(token -> token.contains("dmz"))) {
-            ButtonHelper.deleteMessage(event);
-            return;
-        }
-
-        AddUnitService.addUnits(
-                event, game.getTileFromPlanet(planetName), game, player.getColor(), "1 gf " + planetName);
-        game.setStoredValue(stateKey, String.valueOf(placed + 1));
-        MessageHelper.sendMessageToChannel(
-                event.getMessageChannel(),
-                player.getRepresentation() + " placed 1 infantry on " + Helper.getPlanetRepresentation(planetName, game)
-                        + " with _Power Word: Miracle_ (" + (placed + 1) + "/4)."
-                        + (placed == 3 ? " Press **Done Placing Infantry** when finished." : ""));
-    }
-
-    @ButtonHandler(FINISH_INFANTRY)
-    public static void finishMiracleInfantry(ButtonInteractionEvent event, Game game, Player player, String buttonID) {
-        if (game == null || player == null) {
-            ButtonHelper.deleteMessage(event);
-            return;
-        }
-
-        try {
-            int round = Integer.parseInt(buttonID.substring(FINISH_INFANTRY.length()));
-            game.removeStoredValue(INFANTRY_PLACED + player.getFaction() + "_" + round);
-        } catch (NumberFormatException ignored) {
-            // The message is still safe to remove if an old or malformed completion button is pressed.
-        }
-        ButtonHelper.deleteMessage(event);
-    }
-
-    private static List<Button> getMiracleInfantryButtons(Game game, Player player, int round) {
-        List<Button> planetButtons = new ArrayList<>();
-        for (String planetName : player.getPlanetsAllianceMode()) {
-            Planet planet = game.getUnitHolderFromPlanet(planetName);
-            if (planet == null
-                    || planet.isSpaceStation(game)
-                    || planet.getTokenList().stream().anyMatch(token -> token.contains("dmz"))) {
-                continue;
-            }
-            planetButtons.add(Buttons.green(
-                    player.factionButtonChecker() + PLACE_INFANTRY + round + "_" + planetName,
-                    "Add 1 infantry to " + Helper.getPlanetRepresentation(planetName, game),
-                    UnitEmojis.infantry));
-        }
-        return planetButtons;
-    }
 }
diff --git a/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumUnitHandler.java b/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumUnitHandler.java
index b7d8b220d1..556a774564 100644
--- a/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumUnitHandler.java
+++ b/src/main/java/ti4/discord/interactions/buttons/handlers/faction/homebrew/theodisi/Arcanum/ArcanumUnitHandler.java
@@ -11,12 +11,18 @@
 import ti4.game.Planet;
 import ti4.game.Player;
 import ti4.game.Tile;
+import ti4.game.UnitHolder;
 import ti4.helpers.ButtonHelper;
+import ti4.helpers.Constants;
 import ti4.helpers.Helper;
 import ti4.helpers.Units.UnitType;
 import ti4.image.Mapper;
 import ti4.message.MessageHelper;
+import ti4.model.CombatModifierModel;
+import ti4.model.NamedCombatModifierModel;
 import ti4.model.TechnologyModel;
+import ti4.model.TechnologyModel.TechnologyType;
+import ti4.service.combat.CombatRollType;
 import ti4.service.unit.AddUnitService;
 
 @UtilityClass
@@ -124,4 +130,45 @@ public static void resolveRuneboundInfPlacement(
                         + Helper.getPlanetRepresentation(planetName, game)
                         + " using a Rune-Bound Sentinel (Arcanum mech).");
     }
+
+    // Flagship
+    public static List<NamedCombatModifierModel> getAstralCodexExtraRollModifier(
+            Player player, Tile tile, UnitHolder combatOnHolder, CombatRollType rollType) {
+        if (player == null
+                || tile == null
+                || combatOnHolder == null
+                || rollType != CombatRollType.combatround
+                || !Constants.SPACE.equalsIgnoreCase(combatOnHolder.getName())
+                || !ButtonHelper.doesPlayerHaveFSHere("arcanum_flagship", player, tile)) {
+            return List.of();
+        }
+
+        TechnologyType selectedColor = TechnologyType.NONE;
+        int extraDice = 0;
+        for (TechnologyType color : TechnologyType.mainFour) {
+            int techCount = ButtonHelper.getNumberOfCertainTypeOfTech(player, color);
+            if (techCount > extraDice) {
+                selectedColor = color;
+                extraDice = techCount;
+            }
+        }
+
+        if (extraDice == 0) {
+            return List.of();
+        }
+
+        CombatModifierModel modifier = new CombatModifierModel();
+        modifier.setAlias("arcanum_astral_codex");
+        modifier.setType(Constants.COMBAT_EXTRA_ROLLS);
+        modifier.setValue(extraDice);
+        modifier.setPersistenceType("ALWAYS");
+        modifier.setScope("fs");
+        modifier.setRelated(List.of());
+        modifier.setForCombatAbility(CombatRollType.combatround);
+
+        return List.of(new NamedCombatModifierModel(
+                modifier,
+                "_The Astral Codex_: +" + extraDice + " dice from owning " + extraDice + " "
+                        + selectedColor.readableName() + " technology"));
+    }
 }
diff --git a/src/main/java/ti4/discord/interactions/commands/planet/PlanetExhaustAbility.java b/src/main/java/ti4/discord/interactions/commands/planet/PlanetExhaustAbility.java
index 62e646f96e..8a646abbe2 100644
--- a/src/main/java/ti4/discord/interactions/commands/planet/PlanetExhaustAbility.java
+++ b/src/main/java/ti4/discord/interactions/commands/planet/PlanetExhaustAbility.java
@@ -6,6 +6,7 @@
 import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
 import net.dv8tion.jda.api.events.interaction.GenericInteractionCreateEvent;
 import ti4.discord.interactions.buttons.Buttons;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumPrimordialTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Ponthous.PonthousAbilityHandler;
 import ti4.game.Game;
 import ti4.game.Player;
@@ -43,6 +44,11 @@ public void doAction(GenericInteractionCreateEvent event, Player player, String
     public static void doAction(
             GenericInteractionCreateEvent event, Player player, String planet, Game game, boolean exhaust) {
         if (player == null) return;
+        planet = AliasHandler.resolvePlanet(planet);
+        if (("innersanctum".equals(planet) && !player.hasTech("thveylorg"))
+                || ("fabricatestation".equals(planet) && !player.hasTech("tharcanumpmy"))) {
+            return;
+        }
         if (exhaust) {
             player.exhaustPlanetAbility(planet);
         }
@@ -175,6 +181,12 @@ private static void resolveAbility(GenericInteractionCreateEvent event, Player p
                 // MessageHelper.sendMessageToChannelWithPersistentReacts(game.getActionsChannel(), "Please indicate
                 // \"no afters\" again.", game, afterButtons, GameMessageType.AGENDA_AFTER);
             }
+            case "innersanctum" -> {
+                output = player.getRepresentation()
+                        + ", predict an outcome. If correct, each player who voted for that outcome draws 1 action card.";
+                buttons.addAll(
+                        AgendaRiderHelper.getAgendaButtons("Inner Sanctum", game, player.factionButtonChecker()));
+            }
             case "prism" -> {
                 output = player.getFactionEmoji() + ", please choose a technology to return.";
                 buttons.addAll(getNewPrismLoseTechOptions(player));
@@ -186,6 +198,10 @@ private static void resolveAbility(GenericInteractionCreateEvent event, Player p
                     buttons.addAll(PonthousAbilityHandler.offerFracturedSouls(player));
                 }
             }
+            case "fabricatestation" -> {
+                ArcanumPrimordialTechHandler.offerFabricateStationProduction(event, game, player);
+                output = "blank";
+            }
             case "echo" -> {
                 output =
                         "Use buttons to place a frontier token in a system with no planets.\n-# Cannot yet place a double frontier token in a system, sorry.";
diff --git a/src/main/java/ti4/game/Game.java b/src/main/java/ti4/game/Game.java
index 9cbe7cff20..62a70f47cc 100644
--- a/src/main/java/ti4/game/Game.java
+++ b/src/main/java/ti4/game/Game.java
@@ -3982,6 +3982,8 @@ public Set<String> getPlanets() {
         planets.put("triad", new Planet("triad", new Point(0, 0)));
         planets.put("grove", new Planet("grove", new Point(0, 0)));
         planets.put("aurelionstation", new Planet("aurelionstation", new Point(0, 0)));
+        planets.put("innersanctum", new Planet("innersanctum", new Point(0, 0)));
+        planets.put("fabricatestation", new Planet("fabricatestation", new Point(0, 0)));
         return planets.keySet();
     }
 
diff --git a/src/main/java/ti4/game/Player.java b/src/main/java/ti4/game/Player.java
index 0750bcbb0d..c5177f1765 100644
--- a/src/main/java/ti4/game/Player.java
+++ b/src/main/java/ti4/game/Player.java
@@ -2632,6 +2632,18 @@ private void doAdditionalThingsWhenAddingTech(String techID) {
             }
         }
 
+        if ("thveylorg".equalsIgnoreCase(techID)) {
+            addPlanet("innersanctum");
+            refreshPlanet("innersanctum");
+        }
+
+        if ("tharcanumpmy".equalsIgnoreCase(techID)) {
+            addPlanet("fabricatestation");
+            refreshPlanet("fabricatestation");
+        }
+
+        ArcanumLeadersHandler.offerVeylaTheKeeperButtons(game, this, techID);
+
         // Update Owned Units when Researching a Unit Upgrade
         TechnologyModel techModel = Mapper.getTech(techID);
         if (techID == null) return;
@@ -2683,6 +2695,14 @@ private void doAdditionalThingsWhenRemovingTech(String techID) {
             removeCustodiaVigilia();
         }
 
+        // Remove inner sanctum
+        if (techID != null && techID.toLowerCase().contains("thveylorg")) {
+            removePlanet("innersanctum");
+        }
+        if (techID != null && techID.toLowerCase().contains("tharcanumpmy")) {
+            removePlanet("fabricatestation");
+        }
+
         // Update Owned Units when Researching a Unit Upgrade
         TechnologyModel techModel = Mapper.getTech(techID);
         if (techID == null || techModel == null) return;
diff --git a/src/main/java/ti4/helpers/AgendaHelper.java b/src/main/java/ti4/helpers/AgendaHelper.java
index e1dd6ec7ab..8e28591ba8 100644
--- a/src/main/java/ti4/helpers/AgendaHelper.java
+++ b/src/main/java/ti4/helpers/AgendaHelper.java
@@ -907,6 +907,17 @@ public static List<Player> getWinningRiders(String winner, Game game, GenericInt
                         SettlementsAcd2ButtonHandler.resolveWinningSettlements(game, winningR, winner);
                     }
 
+                    if (winningR != null && winningR.hasTech("thveylorg") && specificVote.contains("Inner Sanctum")) {
+                        for (Player voter : getWinningVoters(winner, game)) {
+                            ActionCardHelper.drawActionCards(voter, 1);
+                        }
+                        MessageHelper.sendMessageToChannel(
+                                game.getMainGameChannel(),
+                                winningR.getRepresentationNoPing()
+                                        + " correctly predicted the outcome with _Inner Sanctum_. "
+                                        + "Each player who voted for that outcome drew 1 action card.");
+                    }
+
                     if (winningR != null
                             && (specificVote.contains("Rider")
                                     || (winningR.hasAbility("future_sight")
diff --git a/src/main/java/ti4/helpers/AgendaWhensAftersHelper.java b/src/main/java/ti4/helpers/AgendaWhensAftersHelper.java
index b494ea3937..61bab22844 100644
--- a/src/main/java/ti4/helpers/AgendaWhensAftersHelper.java
+++ b/src/main/java/ti4/helpers/AgendaWhensAftersHelper.java
@@ -341,6 +341,12 @@ public static List<String> getPossibleAfterNames(Player player) {
                 && !player.getExhaustedPlanetsAbilities().contains(planet)) {
             names.add("Tarrock Ability");
         }
+        String sanctum = "innersanctum";
+        if (player.hasTech("thveylorg")
+                && player.getPlanets().contains(sanctum)
+                && !player.getExhaustedPlanetsAbilities().contains(sanctum)) {
+            names.add("Inner Sanctum Ability");
+        }
 
         if (player.hasLeaderUnlocked("keleresheroodlynn")) {
             names.add("Keleres Hero");
@@ -393,6 +399,12 @@ private static List<Button> getPossibleAferButtons(Player player) {
                 && !player.getExhaustedPlanetsAbilities().contains(planet)) {
             buttons.add(Buttons.red("queueAfter_planet_" + planet, "Tarrock Ability"));
         }
+        String sanctum = "innersanctum";
+        if (player.hasTech("thveylorg")
+                && player.getPlanets().contains(sanctum)
+                && !player.getExhaustedPlanetsAbilities().contains(sanctum)) {
+            buttons.add(Buttons.red("queueAfter_planet_" + sanctum, "Use Inner Sanctum Ability"));
+        }
 
         if (player.getGame().playerHasLeaderUnlockedOrAlliance(player, "atokeracommander")) {
             buttons.add(Buttons.red("queueAfter_leader_Atokera Commander", "Atokera Commander Ability"));
@@ -582,7 +594,7 @@ private static void resolveAfterQueue(ButtonInteractionEvent event, Game game, b
                                 }
                             }
                             case "pn" -> PromissoryNoteHelper.resolvePNPlay(after, player, game, event);
-                            case "planet" -> PlanetExhaustAbility.doAction(event, player, "tarrock", game, true);
+                            case "planet" -> PlanetExhaustAbility.doAction(event, player, after, game, true);
                             case "tech" -> {
                                 player.exhaustTech("dsedyng");
                                 riderButtons = AgendaRiderHelper.getAgendaButtons(
@@ -998,6 +1010,14 @@ public static List<Button> getAfterButtons(Game game) {
                             "Use Tarrock Ability",
                             player.getFactionEmoji()));
                 }
+                if (player.hasTech("thveylorg")
+                        && player.getPlanets().contains("innersanctum")
+                        && !player.getExhaustedPlanetsAbilities().contains("innersanctum")) {
+                    afterButtons.add(Buttons.green(
+                            factionChecker + "planetAbilityExhaust_innersanctum",
+                            "Use Inner Sanctum Ability",
+                            player.getFactionEmoji()));
+                }
             }
         }
 
diff --git a/src/main/java/ti4/helpers/ButtonHelperAbilities.java b/src/main/java/ti4/helpers/ButtonHelperAbilities.java
index 5a7e11452a..8f77c26a96 100644
--- a/src/main/java/ti4/helpers/ButtonHelperAbilities.java
+++ b/src/main/java/ti4/helpers/ButtonHelperAbilities.java
@@ -1991,7 +1991,11 @@ public static List<String> getPossibleTechForNekroToGainFromPlayer(
             return techToGain;
         }
         for (String tech : victim.getTechs()) {
-            if (!nekro.getTechs().contains(tech) && !techToGain.contains(tech) && !"iihq".equalsIgnoreCase(tech)) {
+            if (!nekro.getTechs().contains(tech)
+                    && !techToGain.contains(tech)
+                    && !"iihq".equalsIgnoreCase(tech)
+                    && !"thveylorg".equalsIgnoreCase(tech)
+                    && !"tharcanumpmy".equalsIgnoreCase(tech)) {
                 if (!game.playerHasLeaderUnlockedOrAlliance(victim, "bastioncommander")
                         || !Mapper.getTech(tech).isFactionTech()) {
                     if (game.isTwilightsFallMode()
diff --git a/src/main/java/ti4/helpers/ButtonHelperTacticalAction.java b/src/main/java/ti4/helpers/ButtonHelperTacticalAction.java
index f7dfd0ad7e..f4f1c49317 100644
--- a/src/main/java/ti4/helpers/ButtonHelperTacticalAction.java
+++ b/src/main/java/ti4/helpers/ButtonHelperTacticalAction.java
@@ -20,6 +20,7 @@
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Aeterna.AeternaLeadersHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Aeterna.AeternaUnitsHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumBreakthroughHandler;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumPrimordialTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Ardentia.ArdentiaTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Ardentia.ArdentiaUnitHandler;
@@ -200,6 +201,7 @@ public static void endOfTacticalActionThings(Player player, Game game, ButtonInt
         }
         ArdentiaTechHandler.clearOverlordMatrixGalvanization(game);
         ArcanumBreakthroughHandler.clearPowerWordWish(game);
+        ArcanumPrimordialTechHandler.clearPowerWordPlaneShift(game);
         ArcanumTechHandler.clearSigilOfTransmutation(game);
         AeternaLeadersHandler.clearAeternaCommanderActionState(game);
         AeternaUnitsHandler.clearCryptActionState(game);
@@ -494,6 +496,7 @@ public static void resetStoredValuesForTacticalAction(Game game) {
         XytherisLeadersHandler.clearHeroUnitAbilityRoll(game);
         PonthousUnitHandler.clearOldGlorySustain(game);
         ArcanumBreakthroughHandler.clearPowerWordWish(game);
+        ArcanumPrimordialTechHandler.clearPowerWordPlaneShift(game);
         ArcanumTechHandler.clearSigilOfTransmutation(game);
         KairnTechHandler.clearSurveyorsLensFragmentWindows(game);
         KryxosBreakthroughHandler.clearPrototypeInnovators(game);
diff --git a/src/main/java/ti4/helpers/CheckDistanceHelper.java b/src/main/java/ti4/helpers/CheckDistanceHelper.java
index 46e4d88550..3ff1ebdd8f 100644
--- a/src/main/java/ti4/helpers/CheckDistanceHelper.java
+++ b/src/main/java/ti4/helpers/CheckDistanceHelper.java
@@ -8,6 +8,7 @@
 import java.util.Set;
 import lombok.experimental.UtilityClass;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.beans.DreamButtonHandler;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumPrimordialTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Thrones.ThronesLeadersHandler;
 import ti4.game.Game;
 import ti4.game.Player;
@@ -93,6 +94,7 @@ public static Map<String, Integer> getTileDistances(
                                     && !DreamButtonHandler.playerIgnoresDreamAgentAnomaly(game, player, tile)
                                     && !player.getRelics().contains("circletofthevoid")
                                     && !ThronesLeadersHandler.veythrosIgnoresAnomalies(game, player)
+                                    && !ArcanumPrimordialTechHandler.planeShiftIgnoresAnomalies(game, player)
                                     && !player.hasAbility("voidborn")
                                     && !ButtonHelper.doesPlayerHaveFSHere("purpletf_flagship", player, tile2)
                                     && !ButtonHelper.isLawInPlay(game, "shared_research"))
@@ -101,6 +103,7 @@ public static Map<String, Integer> getTileDistances(
                                     && !DreamButtonHandler.playerIgnoresDreamAgentAnomaly(game, player, tile)
                                     && !player.getRelics().contains("circletofthevoid")
                                     && !ThronesLeadersHandler.veythrosIgnoresAnomalies(game, player)
+                                    && !ArcanumPrimordialTechHandler.planeShiftIgnoresAnomalies(game, player)
                                     && !ButtonHelper.doesPlayerHaveFSHere("purpletf_flagship", player, tile2)
                                     && !player.hasAbility("gashlai_physiology")
                                     && !player.hasTech("tf-mr"))
@@ -121,6 +124,7 @@ public static Map<String, Integer> getTileDistances(
                                     && !player.hasTech("wavelength")
                                     && !player.getRelics().contains("circletofthevoid")
                                     && !ThronesLeadersHandler.veythrosIgnoresAnomalies(game, player)
+                                    && !ArcanumPrimordialTechHandler.planeShiftIgnoresAnomalies(game, player)
                                     && !player.hasTech("absol_amd")
                                     && !ButtonHelper.doesPlayerHaveFSHere("purpletf_flagship", player, tile2))) {
                         continue;
@@ -129,7 +133,8 @@ public static Map<String, Integer> getTileDistances(
                 if (!forMap) {
                     if (tile != null
                             && tile.isGravityRift(game, player)
-                            && !DreamButtonHandler.playerIgnoresDreamAgentAnomaly(game, player, tile)) {
+                            && !DreamButtonHandler.playerIgnoresDreamAgentAnomaly(game, player, tile)
+                            && !ArcanumPrimordialTechHandler.planeShiftIgnoresAnomalies(game, player)) {
                         num = -1;
                         if (game.isCosmicPhenomenaeMode()) {
                             num = -2;
diff --git a/src/main/java/ti4/helpers/CombatModHelper.java b/src/main/java/ti4/helpers/CombatModHelper.java
index 1b4f7daac0..e29ab72372 100644
--- a/src/main/java/ti4/helpers/CombatModHelper.java
+++ b/src/main/java/ti4/helpers/CombatModHelper.java
@@ -12,6 +12,7 @@
 import java.util.stream.Collectors;
 import lombok.experimental.UtilityClass;
 import org.apache.commons.lang3.StringUtils;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumPrimordialTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.whispers.arvaxi.ArvaxiBreakthroughHandler;
 import ti4.game.Game;
 import ti4.game.Leader;
@@ -459,6 +460,7 @@ private static Boolean checkModPassesCondition(
                         && activePlayer != null
                         && !activePlayer.getUserID().equals(player.getUserID())
                         && !activePlayer.getAllianceMembers().contains(player.getFaction())
+                        && !ArcanumPrimordialTechHandler.planeShiftIgnoresAnomalies(game, activePlayer)
                         && !game.getStoredValue("mahactHeroTarget").equalsIgnoreCase(player.getFaction())) {
                     meetsCondition = true;
                 }
@@ -471,6 +473,7 @@ private static Boolean checkModPassesCondition(
                         && activePlayer != null
                         && !activePlayer.getUserID().equals(player.getUserID())
                         && !activePlayer.getAllianceMembers().contains(player.getFaction())
+                        && !ArcanumPrimordialTechHandler.planeShiftIgnoresAnomalies(game, activePlayer)
                         && !game.getStoredValue("mahactHeroTarget").equalsIgnoreCase(player.getFaction())) {
                     meetsCondition = true;
                 }
diff --git a/src/main/java/ti4/helpers/ComponentActionHelper.java b/src/main/java/ti4/helpers/ComponentActionHelper.java
index 7f95312d61..3c7f9920d1 100644
--- a/src/main/java/ti4/helpers/ComponentActionHelper.java
+++ b/src/main/java/ti4/helpers/ComponentActionHelper.java
@@ -16,6 +16,7 @@
 import ti4.discord.interactions.buttons.Buttons;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Aeterna.AeternaAbilityHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumAbilityHandler;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumPrimordialTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Ardentia.ArdentiaAbilityHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Kairn.KairnBreakthroughHandler;
@@ -86,7 +87,12 @@ public static List<Button> getAllPossibleCompButtons(Game game, Player p1, Gener
                 if ("thobliviong".equalsIgnoreCase(tech) && !OblivionTechHandler.canUseMirroredMemories(game, p1)) {
                     continue;
                 }
-                if ("tharcanumpmg".equalsIgnoreCase(tech) && !ArcanumTechHandler.hasFourTechsMatchingPrimordial(p1)) {
+                if (("tharcanumpmg".equalsIgnoreCase(tech) || "tharcanumpmb".equalsIgnoreCase(tech))
+                        && !ArcanumPrimordialTechHandler.hasFourTechsMatchingPrimordial(p1, tech)) {
+                    continue;
+                }
+                if ("tharcanumpmb".equalsIgnoreCase(tech)
+                        && !ArcanumPrimordialTechHandler.canUsePowerWordPlaneShift(game, p1)) {
                     continue;
                 }
                 if ("lgf".equals(tech) && !p1.controlsMecatol(false)) {
@@ -161,11 +167,12 @@ public static List<Button> getAllPossibleCompButtons(Game game, Player p1, Gener
                 }
             }
         }
-        List<String> implementedLegendaryPlanets = new ArrayList<>(List.of("avernus"));
+        List<String> implementedLegendaryPlanets = new ArrayList<>(List.of("avernus", "fabricatestation"));
         for (String planet : implementedLegendaryPlanets) {
             String prettyPlanet = Mapper.getPlanet(planet).getName();
             if (p1.getPlanets().contains(planet)
-                    && !p1.getExhaustedPlanetsAbilities().contains(planet)) {
+                    && !p1.getExhaustedPlanetsAbilities().contains(planet)
+                    && (!"fabricatestation".equals(planet) || p1.hasTech("tharcanumpmy"))) {
                 compButtons.add(Buttons.green(
                         factionChecker + "planetAbilityExhaust_" + planet, "Use " + prettyPlanet + " Ability"));
             }
diff --git a/src/main/java/ti4/helpers/RiftUnitsHelper.java b/src/main/java/ti4/helpers/RiftUnitsHelper.java
index 47a730fa44..dbae951a46 100644
--- a/src/main/java/ti4/helpers/RiftUnitsHelper.java
+++ b/src/main/java/ti4/helpers/RiftUnitsHelper.java
@@ -11,6 +11,7 @@
 import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
 import org.apache.commons.lang3.function.Consumers;
 import ti4.discord.interactions.buttons.Buttons;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumPrimordialTechHandler;
 import ti4.discord.interactions.routing.ButtonHandler;
 import ti4.game.Game;
 import ti4.game.Planet;
@@ -445,6 +446,13 @@ public static void doneRifting(Game game, Player player, ButtonInteractionEvent
 
     @ButtonHandler("getRiftButtons_")
     public static void offerRiftButtons(Player player, String buttonID, Game game) {
+        if (ArcanumPrimordialTechHandler.planeShiftIgnoresAnomalies(game, player)) {
+            MessageHelper.sendMessageToChannel(
+                    player.getCorrectChannel(),
+                    player.getRepresentationNoPing()
+                            + " ignores gravity-rift effects during this tactical action due to _Power Word: Plane Shift_.");
+            return;
+        }
         String tilePosition = buttonID.replace("getRiftButtons_", "");
         Tile tile = game.getTileByPosition(tilePosition);
         MessageChannel channel = player.getCorrectChannel();
diff --git a/src/main/java/ti4/model/TechnologyModel.java b/src/main/java/ti4/model/TechnologyModel.java
index be6ed5eef1..0cf05fd141 100644
--- a/src/main/java/ti4/model/TechnologyModel.java
+++ b/src/main/java/ti4/model/TechnologyModel.java
@@ -347,6 +347,14 @@ public TI4Emoji getSingleTechEmoji() {
 
     public String getCondensedReqsEmojis(boolean single) {
         String reqs = getRequirements().orElse("");
+        if (single && "arcanum".equalsIgnoreCase(getFaction().orElse("")) && types.size() == 2) {
+            if (isBioticTech() && isPropulsionTech()) return TechEmojis.BioticPropulsion.toString();
+            if (isBioticTech() && isCyberneticTech()) return TechEmojis.BioticCybernetic.toString();
+            if (isBioticTech() && isWarfareTech()) return TechEmojis.BioticWarfare.toString();
+            if (isCyberneticTech() && isPropulsionTech()) return TechEmojis.CyberneticPropulsion.toString();
+            if (isCyberneticTech() && isWarfareTech()) return TechEmojis.CyberneticWarfare.toString();
+            if (isWarfareTech() && isPropulsionTech()) return TechEmojis.WarfarePropulsion.toString();
+        }
         StringBuilder output = new StringBuilder();
         Set<TechnologyType> types = new HashSet<>(this.types);
         for (TechnologyType type : types) {
@@ -358,6 +366,7 @@ public String getCondensedReqsEmojis(boolean single) {
                         case "B" -> output.append(TechEmojis.PropulsionTech);
                         case "BB" -> output.append(TechEmojis.Propulsion2);
                         case "BBB" -> output.append(TechEmojis.Propulsion3);
+                        case "BBBB" -> output.append(TechEmojis.Propulsion4);
                     }
                 }
                 case CYBERNETIC -> {
@@ -367,6 +376,7 @@ public String getCondensedReqsEmojis(boolean single) {
                         case "Y" -> output.append(TechEmojis.CyberneticTech);
                         case "YY" -> output.append(TechEmojis.Cybernetic2);
                         case "YYY" -> output.append(TechEmojis.Cybernetic3);
+                        case "YYYY" -> output.append(TechEmojis.Cybernetic4);
                     }
                 }
                 case BIOTIC -> {
@@ -376,6 +386,7 @@ public String getCondensedReqsEmojis(boolean single) {
                         case "G" -> output.append(TechEmojis.BioticTech);
                         case "GG" -> output.append(TechEmojis.Biotic2);
                         case "GGG" -> output.append(TechEmojis.Biotic3);
+                        case "GGGG" -> output.append(TechEmojis.Biotic4);
                     }
                 }
                 case WARFARE -> {
@@ -385,6 +396,7 @@ public String getCondensedReqsEmojis(boolean single) {
                         case "R" -> output.append(TechEmojis.WarfareTech);
                         case "RR" -> output.append(TechEmojis.Warfare2);
                         case "RRR" -> output.append(TechEmojis.Warfare3);
+                        case "RRRR" -> output.append(TechEmojis.Warfare4);
                     }
                 }
                 case UNITUPGRADE -> {
diff --git a/src/main/java/ti4/service/combat/CombatRollService.java b/src/main/java/ti4/service/combat/CombatRollService.java
index 8cad13a0c9..0fedaf7c59 100644
--- a/src/main/java/ti4/service/combat/CombatRollService.java
+++ b/src/main/java/ti4/service/combat/CombatRollService.java
@@ -44,6 +44,7 @@
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Aeterna.AeternaBreakthroughHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumBreakthroughHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumTechHandler;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumUnitHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Ardentia.ArdentiaUnitHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Kryxos.KryxosBreakthroughHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Revenant.RevenantTechHandler;
@@ -497,6 +498,10 @@ public static int secondHalfOfCombatRoll(
             extraRolls.addAll(IronFactionTechsHandler.getAdvancedTargetingSystemsExtraRollModifier(
                     game, player, opponent, tile, combatOnHolder, rollType));
         }
+        if (player.ownsUnit("arcanum_flagship")) {
+            extraRolls.addAll(
+                    ArcanumUnitHandler.getAstralCodexExtraRollModifier(player, tile, combatOnHolder, rollType));
+        }
 
         CombatRollResult rollResult = rollForUnitsWithResult(
                 playerUnitsByQuantity,
diff --git a/src/main/java/ti4/service/combat/StartCombatService.java b/src/main/java/ti4/service/combat/StartCombatService.java
index 277ad1b289..e20c21968e 100644
--- a/src/main/java/ti4/service/combat/StartCombatService.java
+++ b/src/main/java/ti4/service/combat/StartCombatService.java
@@ -35,6 +35,7 @@
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Aeterna.AeternaPromissoryHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Aeterna.AeternaTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Aeterna.AeternaUnitsHandler;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumPrimordialTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Ponthous.PonthousBreakthroughHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Ponthous.PonthousLeadersHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Ponthous.PonthousPromissoryHandler;
@@ -1464,6 +1465,18 @@ private static List<Button> getStartOfSpaceCombatButtons(Game game, Player p1, P
             buttons.add(AeternaLeadersHandler.getGravecallButton(game, p2, tile));
         }
 
+        // Arcanum Disintegrate
+        if (p1.hasTech("tharcanumpmr")
+                && ArcanumPrimordialTechHandler.hasFourTechsMatchingPrimordial(p1, "tharcanumpmr")) {
+            buttons.addAll(
+                    ArcanumPrimordialTechHandler.getDisintegrateCombatButtons(p1, p2, tile, tile.getSpaceUnitHolder()));
+        }
+        if (p2.hasTech("tharcanumpmr")
+                && ArcanumPrimordialTechHandler.hasFourTechsMatchingPrimordial(p2, "tharcanumpmr")) {
+            buttons.addAll(
+                    ArcanumPrimordialTechHandler.getDisintegrateCombatButtons(p2, p1, tile, tile.getSpaceUnitHolder()));
+        }
+
         return buttons;
     }
 
diff --git a/src/main/java/ti4/service/emoji/TechEmojis.java b/src/main/java/ti4/service/emoji/TechEmojis.java
index 27372a5126..27cca6623e 100755
--- a/src/main/java/ti4/service/emoji/TechEmojis.java
+++ b/src/main/java/ti4/service/emoji/TechEmojis.java
@@ -8,6 +8,7 @@ public enum TechEmojis implements TI4Emoji {
     PropulsionDisabled,
     Propulsion2,
     Propulsion3,
+    Propulsion4,
 
     BioticBiotic,
     BioticPropulsion,
@@ -17,6 +18,7 @@ public enum TechEmojis implements TI4Emoji {
     BioticDisabled,
     Biotic2,
     Biotic3,
+    Biotic4,
 
     CyberneticWarfare,
     CyberneticPropulsion,
@@ -25,6 +27,7 @@ public enum TechEmojis implements TI4Emoji {
     CyberneticDisabled,
     Cybernetic2,
     Cybernetic3,
+    Cybernetic4,
 
     WarfarePropulsion,
     WarfareWarfare,
@@ -32,6 +35,7 @@ public enum TechEmojis implements TI4Emoji {
     WarfareDisabled,
     Warfare2,
     Warfare3,
+    Warfare4,
 
     UnitUpgradeTech,
     UnitTechSkip,
diff --git a/src/main/java/ti4/service/info/CardsInfoService.java b/src/main/java/ti4/service/info/CardsInfoService.java
index 0559469531..6a1b8eb7bd 100644
--- a/src/main/java/ti4/service/info/CardsInfoService.java
+++ b/src/main/java/ti4/service/info/CardsInfoService.java
@@ -19,6 +19,7 @@
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.beans.ta.TaAbilityHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.beans.ta.TaLeadersHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Aeterna.AeternaUnitsHandler;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumLeadersHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Thrones.ThronesLeadersHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Thrones.ThronesUnitHandler;
 import ti4.discord.interactions.commands.CommandHelper;
@@ -99,6 +100,19 @@ public static void sendVariousAdditionalButtons(Game game, Player player) {
                     "Use Runebearer Lothos on Another Player",
                     FactionEmojis.revenant));
         }
+        if (!"setup".equalsIgnoreCase(game.getPhaseOfGame()) && player.hasUnexhaustedLeader("arcanumagent")) {
+            buttons.add(ArcanumLeadersHandler.getVeylaCardsInfoButton(player));
+        }
+        if ("action".equalsIgnoreCase(game.getPhaseOfGame())
+                && player.isActivePlayer()
+                && player.hasTech("tharcanumpmy")
+                && player.getPlanets().contains("fabricatestation")
+                && !player.getExhaustedPlanetsAbilities().contains("fabricatestation")) {
+            buttons.add(Buttons.green(
+                    player.factionButtonChecker() + "planetAbilityExhaust_fabricatestation",
+                    "Use Fabricate Station Ability",
+                    MiscEmojis.LegendaryPlanet));
+        }
         if (player.hasUnexhaustedLeader("oblivionagent")) {
             buttons.add(Buttons.gray(
                     player.factionButtonChecker() + "useOblivionAgent_other",
diff --git a/src/main/java/ti4/service/leader/PlayHeroService.java b/src/main/java/ti4/service/leader/PlayHeroService.java
index fc8c167b52..f7c669a1f5 100644
--- a/src/main/java/ti4/service/leader/PlayHeroService.java
+++ b/src/main/java/ti4/service/leader/PlayHeroService.java
@@ -18,6 +18,7 @@
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.beans.ashen.AshenLeadersHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.beans.netrunners.NetrunnersLeadersHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.beans.ta.TaLeadersHandler;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumLeadersHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Ardentia.ArdentiaLeadersHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Kairn.KairnLeadershandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Oblivion.OblivionUnitHandler;
@@ -269,6 +270,7 @@ public static void playHero(GenericInteractionCreateEvent event, Game game, Play
             case "throneshero" -> ThronesLeadersHandler.getUnplacedThronePlanetButtons(event, game, player);
             case "kairnhero" -> KairnLeadershandler.startKairnHero(event, game, player);
             case "ponthoushero" -> PonthousLeadersHandler.startPonthousHero(event, game, player);
+            case "arcanumhero" -> ArcanumLeadersHandler.startArcanumHero(event, game, player);
             case "florzenhero" -> {
                 for (Tile tile : game.getTileMap().values()) {
                     for (UnitHolder uH : tile.getPlanetUnitHolders()) {
diff --git a/src/main/java/ti4/service/tactical/TacticalActionOutputService.java b/src/main/java/ti4/service/tactical/TacticalActionOutputService.java
index a90a3ad0c2..132caf17ae 100644
--- a/src/main/java/ti4/service/tactical/TacticalActionOutputService.java
+++ b/src/main/java/ti4/service/tactical/TacticalActionOutputService.java
@@ -15,6 +15,7 @@
 import ti4.discord.interactions.buttons.Buttons;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.beans.DreamButtonHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumBreakthroughHandler;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumPrimordialTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Thrones.ThronesLeadersHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.whispers.arvaxi.ArvaxiBreakthroughHandler;
 import ti4.game.Game;
@@ -269,6 +270,7 @@ private String validateMoveValue(
 
         StringBuilder output = new StringBuilder();
         int maxBonus = 0;
+        boolean ignoresAnomalies = ArcanumPrimordialTechHandler.planeShiftIgnoresAnomalies(game, player);
         if (distance > moveValue && distance < 90 && !game.isL1Hero()) {
             output.append(" (distance exceeds move value (")
                     .append(distance)
@@ -308,18 +310,22 @@ private String validateMoveValue(
                 output.append(" (has _Lightning Drives_ for +1 movement if not transporting)");
             }
             if (riftDistance < distance) {
-                // maxBonus += distance - riftDistance; // Don't automatically count rifts, allow the GM to verify
-                output.append(" (gravity rifts along a path could add +")
-                        .append(distance - riftDistance)
-                        .append(" movement if used)");
-                if (player.hasRelic("circletofthevoid")) {
-                    output.append(" (Does not roll for rifts due to circlet of the void)");
-                }
-                if (game.playerHasLeaderUnlockedOrAlliance(player, "thronescommander")) {
-                    output.append(
-                            " (Gravity rift move effects are optional due to _Veythros_ the Thrones of Ruin commander. If you do ignore rift, you do not get the +1 to move.)");
+                if (ignoresAnomalies) {
+                    output.append(" (ignores gravity-rift effects due to _Power Word: Plane Shift_)");
+                } else {
+                    // Don't automatically count rifts, allowing the player to verify the chosen path.
+                    output.append(" (gravity rifts along a path could add +")
+                            .append(distance - riftDistance)
+                            .append(" movement if used)");
+                    if (player.hasRelic("circletofthevoid")) {
+                        output.append(" (does not roll for rifts due to Circlet of the Void)");
+                    }
+                    if (game.playerHasLeaderUnlockedOrAlliance(player, "thronescommander")) {
+                        output.append(
+                                " (gravity-rift movement effects are optional due to _Veythros, the Thrones of Ruin commander_; if you ignore the rift, you do not get the +1 movement)");
+                    }
+                    game.setStoredValue("possiblyUsedRift", "yes");
                 }
-                game.setStoredValue("possiblyUsedRift", "yes");
             }
             if (player.hasTech("bedreamneg")) {
                 output.append(
@@ -342,7 +348,7 @@ private String validateMoveValue(
         if (distance > 90 && player.hasAbility("sundered")) {
             output.append(" (__Warning__: has **Sundered**, and so cannot use wormholes)");
         }
-        if (riftDistance < distance) {
+        if (riftDistance < distance && !ignoresAnomalies) {
             game.setStoredValue("possiblyUsedRift", "yes");
         }
         if (player.hasAbility("celestial_guides")) {
@@ -372,7 +378,8 @@ private int getUnitMoveValue(
                 && !player.hasAbility("voidborn")
                 && !player.hasTech("absol_amd")
                 && !player.getRelics().contains("circletofthevoid")
-                && !ThronesLeadersHandler.veythrosIgnoresAnomalies(game, player)) {
+                && !ThronesLeadersHandler.veythrosIgnoresAnomalies(game, player)
+                && !ArcanumPrimordialTechHandler.planeShiftIgnoresAnomalies(game, player)) {
             baseMoveValue = 1;
         }
         if (skipBonus) return baseMoveValue;
diff --git a/src/main/java/ti4/service/tactical/TacticalActionService.java b/src/main/java/ti4/service/tactical/TacticalActionService.java
index ab5df43045..df6ac1b7e6 100644
--- a/src/main/java/ti4/service/tactical/TacticalActionService.java
+++ b/src/main/java/ti4/service/tactical/TacticalActionService.java
@@ -11,6 +11,7 @@
 import ti4.discord.interactions.buttons.Buttons;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.beans.Iron.IronLeadersHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumBreakthroughHandler;
+import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Arcanum.ArcanumPrimordialTechHandler;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Ardentia.*;
 import ti4.discord.interactions.buttons.handlers.faction.homebrew.theodisi.Xytheris.XytherisLeadersHandler;
 import ti4.game.Game;
@@ -438,6 +439,7 @@ private boolean shouldSkipPlacingAbilities(Game game, Player player) {
         return game.isNaaluAgent()
                 || game.isWarfareAction()
                 || game.isL1Hero()
+                || ArcanumPrimordialTechHandler.planeShiftIgnoresAnomalies(game, player)
                 || (!game.getStoredValue("hiredGunsInPlay").isEmpty() && player != game.getActivePlayer());
     }
 
diff --git a/src/main/java/ti4/service/tech/ListTechService.java b/src/main/java/ti4/service/tech/ListTechService.java
index c84dbdbe9d..45fd246d64 100644
--- a/src/main/java/ti4/service/tech/ListTechService.java
+++ b/src/main/java/ti4/service/tech/ListTechService.java
@@ -220,7 +220,7 @@ public static List<Button> getTechButtons(List<TechnologyModel> techs, Player pl
         return getTechButtons(techs, player, "normal");
     }
 
-    private static boolean isTechResearchable(TechnologyModel tech, Player player) {
+    public static boolean isTechResearchable(TechnologyModel tech, Player player) {
         Game game = player.getGame();
         String requirements = tech.getRequirements().orElse("");
         int wilds = 0;
diff --git a/src/main/java/ti4/service/tech/PlayerTechService.java b/src/main/java/ti4/service/tech/PlayerTechService.java
index 96bb37be04..68579e6b05 100644
--- a/src/main/java/ti4/service/tech/PlayerTechService.java
+++ b/src/main/java/ti4/service/tech/PlayerTechService.java
@@ -102,6 +102,12 @@ public static void addTech(GenericInteractionCreateEvent event, Game game, Playe
         if ("thkairng".equalsIgnoreCase(AliasHandler.resolveTech(techID))) {
             message += "\nYour commodities are now " + player.getCommoditiesTotal();
         }
+        if ("thveylorg".equalsIgnoreCase(AliasHandler.resolveTech(techID))) {
+            message += "\nAdded _Inner Sanctum_ and its planet cards to your play area.";
+        }
+        if ("tharcanumpmy".equalsIgnoreCase(AliasHandler.resolveTech(techID))) {
+            message += "\nAdded _Fabricate Station_ and its planet cards to your play area.";
+        }
         CommanderUnlockCheckService.checkPlayer(player, "mirveda", "jolnar", "nekro", "dihmohn", "kryxos", "arcanum");
         MessageHelper.sendMessageToEventChannel(event, message);
     }
@@ -238,6 +244,11 @@ public static void exhaustTechAndResolve(
                     "No eligible component action card is available in the action card discard pile.");
             return;
         }
+        if ("tharcanumpmb".equals(tech) && !ArcanumPrimordialTechHandler.canUsePowerWordPlaneShift(game, player)) {
+            MessageHelper.sendMessageToChannel(
+                    event.getMessageChannel(), "No system without planets is available for _Power Word: Plane Shift_.");
+            return;
+        }
         String exhaustMessage = player.getRepresentation(false, false) + " exhausted technology "
                 + techModel.getRepresentation(false) + ".";
         game.setStoredValue(
@@ -621,7 +632,11 @@ public static void exhaustTechAndResolve(
                 TaFactionTechHandler.resolveResOp(event, game, player);
             }
             case "tharcanumpmg" -> { // Power Word: Miracle
-                ArcanumTechHandler.resolvePowerWordMiracle(event, game, player);
+                ArcanumPrimordialTechHandler.resolvePowerWordMiracle(event, game, player);
+                deleteTheOneButtonIfButtonEvent(event);
+            }
+            case "tharcanumpmb" -> { // Power Word: Plane Shift
+                ArcanumPrimordialTechHandler.resolvePowerWordPlaneShift(event, game, player);
                 deleteTheOneButtonIfButtonEvent(event);
             }
             default ->
@@ -737,6 +752,16 @@ public static void getTech(Game game, Player player, ButtonInteractionEvent even
             return;
         }
         TechnologyModel techM = Mapper.getTech(techID);
+        if (isResearch
+                && "arcanum".equalsIgnoreCase(techM.getFaction().orElse(""))
+                && !ListTechService.isTechResearchable(techM, player)) {
+            MessageHelper.sendMessageToChannel(
+                    player.getCorrectChannel(),
+                    player.getRepresentation() + " does not meet the prerequisites for "
+                            + techM.getNameRepresentation()
+                            + ".");
+            return;
+        }
         StringBuilder message = new StringBuilder(ident)
                 .append(" acquired the technology ")
                 .append(techM.getRepresentation(false))
diff --git a/src/main/java/ti4/service/unit/UnitModelValueInjectionService.java b/src/main/java/ti4/service/unit/UnitModelValueInjectionService.java
index 4d72252291..9bf808f910 100644
--- a/src/main/java/ti4/service/unit/UnitModelValueInjectionService.java
+++ b/src/main/java/ti4/service/unit/UnitModelValueInjectionService.java
@@ -24,39 +24,40 @@ public UnitModel injectPlayerUnitValues(Player player, UnitModel unit) {
 
     // TODO: Add TF Nomad FS, 3 TF Mechs, TK Xxcha flag, Lightrail
     private UnitValueInjection getPlayerUnitValueInjection(Player player, UnitModel unit) {
+        IntegerValueInjection integers = IntegerValueInjection.create();
+        BooleanValueInjection booleans = BooleanValueInjection.create();
+
+        if (player.hasTech("tharcanumpmy")
+                && player.getPlanets().contains("fabricatestation")
+                && unit.getUnitType() == UnitType.Flagship) {
+            integers.productionValue(3);
+        }
+
         if ("aeterna_flagship".equals(unit.getId())) {
             int tokenCount = AeternaUnitsHandler.getCryptTokenCount(player.getGame(), player);
             if (tokenCount > 0) {
-                return UnitValueInjection.of(IntegerValueInjection.create().capacityValue(2 * tokenCount));
+                integers.capacityValue(2 * tokenCount);
             }
         }
+
         if (player.hasAbility("evolved_warforms") && unit.getUnitType() == UnitType.Mech) {
-            return UnitValueInjection.of(
-                    IntegerValueInjection.create().moveValue(1),
-                    null,
-                    BooleanValueInjection.create()
-                            .isShip(true)
-                            .isPlanetOnly(false)
-                            .isSpaceOnly(false));
+            integers.moveValue(1);
+            booleans.isShip(true).isPlanetOnly(false).isSpaceOnly(false);
         }
+
         if (player.hasUnlockedBreakthrough("xytherisbt")
                 && player.hasUpgradedUnit("pds2")
                 && unit.getUnitType() == UnitType.Pds) {
-            return UnitValueInjection.of(
-                    IntegerValueInjection.create()
-                            .combatDieCount(1)
-                            .combatHitsOn(7)
-                            .capacityUsed(1),
-                    null,
-                    BooleanValueInjection.create()
-                            .isGroundForce(true)
-                            .isShip(true)
-                            .isPlanetOnly(false)
-                            .isSpaceOnly(false)
-                            .sustainDamage(true)
-                            .canBeDirectHit(true));
-        }
-        return UnitValueInjection.empty();
+            integers.combatDieCount(1).combatHitsOn(7).capacityUsed(1);
+            booleans.isGroundForce(true)
+                    .isShip(true)
+                    .isPlanetOnly(false)
+                    .isSpaceOnly(false)
+                    .sustainDamage(true)
+                    .canBeDirectHit(true);
+        }
+
+        return UnitValueInjection.of(integers, null, booleans);
     }
 
     public UnitModel injectValues(UnitModel unit, UnitValueInjection values) {
diff --git a/src/main/java/ti4/website/model/WebTileUnitData.java b/src/main/java/ti4/website/model/WebTileUnitData.java
index 3719da04ca..d929a89fcc 100644
--- a/src/main/java/ti4/website/model/WebTileUnitData.java
+++ b/src/main/java/ti4/website/model/WebTileUnitData.java
@@ -322,7 +322,9 @@ private static WebTileUnitData extractOffTilePlanetsData(Game game) {
                 "ocean5",
                 "triad",
                 "grove",
-                "aurelionstation");
+                "aurelionstation",
+                "innersanctum",
+                "fabricatestation");
 
         Map<String, Planet> planetsInfo = game.getPlanetsInfo();
 
diff --git a/src/main/resources/data/factions/theodisi_factions.json b/src/main/resources/data/factions/theodisi_factions.json
index a78c071096..859db5ca69 100644
--- a/src/main/resources/data/factions/theodisi_factions.json
+++ b/src/main/resources/data/factions/theodisi_factions.json
@@ -510,12 +510,7 @@
             "aeterna"
         ],
         "abilities": [
-            "cycle_of_reclamation",
-            "new_moon_phase",
-            "waxing_moon_phase",
-            "full_moon_phase",
-            "waning_moon_phase",
-            "lunar_eclipse_phase"
+            "cycle_of_reclamation"
         ],
         "leaders": [
             "aeternaagent",
diff --git a/src/main/resources/emojis/tech/Biotic4.png b/src/main/resources/emojis/tech/Biotic4.png
new file mode 100644
index 0000000000..253ed32553
Binary files /dev/null and b/src/main/resources/emojis/tech/Biotic4.png differ
diff --git a/src/main/resources/emojis/tech/Cybernetic4.png b/src/main/resources/emojis/tech/Cybernetic4.png
new file mode 100644
index 0000000000..355fa8a69e
Binary files /dev/null and b/src/main/resources/emojis/tech/Cybernetic4.png differ
diff --git a/src/main/resources/emojis/tech/Propulsion4.png b/src/main/resources/emojis/tech/Propulsion4.png
new file mode 100644
index 0000000000..7c4734e27f
Binary files /dev/null and b/src/main/resources/emojis/tech/Propulsion4.png differ
diff --git a/src/main/resources/emojis/tech/Warfare4.png b/src/main/resources/emojis/tech/Warfare4.png
new file mode 100644
index 0000000000..ba958f6779
Binary files /dev/null and b/src/main/resources/emojis/tech/Warfare4.png differ
diff --git a/src/main/resources/planets/fabricatestation.json b/src/main/resources/planets/fabricatestation.json
index a9c0b8767e..4acdf53853 100644
--- a/src/main/resources/planets/fabricatestation.json
+++ b/src/main/resources/planets/fabricatestation.json
@@ -9,7 +9,8 @@
     "influence":3,
     "planetTypes":[
         "SPACESTATION",
-        "FAKE"
+        "FAKE",
+        "FACTION"
     ],
     "legendaryAbilityName": "Mass Production",
     "legendaryAbilityText": "Your flagship gains PRODUCTION 3. During the action phase you may exhaust this card to use the PRODUCTION effect of one of your units. Units produced by this effect may be placed in any system that contains your ships and no other player's units.",
diff --git a/src/main/resources/planets/innersanctum.json b/src/main/resources/planets/innersanctum.json
index ea67c4cebf..decb74317d 100644
--- a/src/main/resources/planets/innersanctum.json
+++ b/src/main/resources/planets/innersanctum.json
@@ -9,7 +9,8 @@
     "resources": 0,
     "influence": 4,
     "planetTypes": [
-        "FAKE"
+        "FAKE",
+        "FACTION"
     ],
     "legendaryAbilityName": "Sabotaged Legislation",
     "legendaryAbilityText": "After an agenda is revealed, you may exhaust this card and predict the outcome of this agenda. If your prediction is correct, each player who voted for the resolved outcome draws 1 action card.",