From c95e9ea5e929d06dd161aa60e360433ef7af47e7 Mon Sep 17 00:00:00 2001
From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 13:43:27 +0100
Subject: [PATCH 1/6] fix: roll saved template results and refuse outputs that
 failed their checks

An output written as result.item: t.<template> was not read as a template:
the loader logged it as an invalid item but kept the output, players could
start it, the station saved the literal t.<template> as its result, and on
completion the item could not be built, so the station stayed stuck.

- A saved result that is still a t.* template is rolled when the project
  completes; the rolled item is saved and granted. A project whose recipe is
  already complete also finishes when its owner opens it again.
- result.item: t.<template> is read as result.template, with a load warning
  telling staff to move it to result.template.
- Outputs that fail their load checks stay listed but cannot be started:
  the player gets station.output_unavailable (with a built-in fallback for
  older messages.yml files) and the console gets a warning naming the
  input and the problem, instead of "Research reload failed".

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../net/tfminecraft/research/Messages.java    |   5 +
 .../research/loader/OutputLoader.java         |  23 +++-
 .../research/manager/ResearchManager.java     |  50 ++++++-
 .../research/model/ActiveProject.java         |   7 +-
 .../tfminecraft/research/model/OutputDef.java |  21 ++-
 .../research/util/ResultResolver.java         |   6 +-
 src/main/resources/messages.yml               |   1 +
 .../research/ResearchTestState.java           |   9 +-
 .../research/ResearchTextAndModelTest.java    |   5 +
 .../research/loader/ResearchLoadersTest.java  |  44 +++++++
 .../research/manager/ResearchManagerTest.java | 122 +++++++++++++++++-
 .../research/util/ResearchUtilitiesTest.java  |  15 +++
 12 files changed, 292 insertions(+), 16 deletions(-)

diff --git a/src/main/java/net/tfminecraft/research/Messages.java b/src/main/java/net/tfminecraft/research/Messages.java
index 9ba2d5a..61c2f27 100644
--- a/src/main/java/net/tfminecraft/research/Messages.java
+++ b/src/main/java/net/tfminecraft/research/Messages.java
@@ -33,6 +33,11 @@ public static String get(String key) {
         return format(key, Map.of());
     }
 
+    /** The message for a key that older messages.yml files may lack: the fallback, with the prefix, until it is added. */
+    public static String getOrDefault(String key, String fallback) {
+        return has(key) ? get(key) : StringFormatter.formatHex(prefix + fallback);
+    }
+
     public static String format(String key, Map<String, String> placeholders) {
         return StringFormatter.formatHex(prefix + formatBodyRaw(key, placeholders));
     }
diff --git a/src/main/java/net/tfminecraft/research/loader/OutputLoader.java b/src/main/java/net/tfminecraft/research/loader/OutputLoader.java
index 9515192..78f1c35 100644
--- a/src/main/java/net/tfminecraft/research/loader/OutputLoader.java
+++ b/src/main/java/net/tfminecraft/research/loader/OutputLoader.java
@@ -4,9 +4,11 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Comparator;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.configuration.InvalidConfigurationException;
@@ -24,11 +26,21 @@
 public final class OutputLoader implements LoaderInterface {
 
     private static final Map<String, OutputDef> map = new LinkedHashMap<>();
+    private static final Set<String> failedChecks = new HashSet<>();
 
     public static Map<String, OutputDef> get() {
         return map;
     }
 
+    /** Ids of loaded outputs that failed a load check. They stay listed, but no project can start them. */
+    public static Set<String> failedChecks() {
+        return failedChecks;
+    }
+
+    public static boolean passedChecks(String id) {
+        return !failedChecks.contains(id);
+    }
+
     public static OutputDef getById(String id) {
         return map.get(id);
     }
@@ -40,6 +52,7 @@ public void load(File configFile) {
 
     public boolean loadFolder(File folder) {
         map.clear();
+        failedChecks.clear();
         boolean ok = true;
         List<File> files = new ArrayList<>(YamlFolder.listYamlFiles(folder));
         files.sort(Comparator.comparing(file -> file.getName().toLowerCase()));
@@ -77,7 +90,10 @@ private boolean loadFile(File configFile) {
             }
 
             OutputDef def = new OutputDef(key, section);
-            ok &= validate(def, configFile);
+            if (!validate(def, configFile)) {
+                failedChecks.add(key);
+                ok = false;
+            }
             map.put(key, def);
         }
         return ok;
@@ -162,6 +178,11 @@ private boolean validateResult(OutputDef def, File configFile) {
                     + "' missing result.item or result.template in " + configFile.getName());
             return false;
         }
+        if (result.isTemplateInItemKey()) {
+            Research.plugin.getLogger().warning("[Research] Output '" + def.getId() + "' sets result.item: "
+                    + result.getTemplateRef().trim() + ", which is a template. It is read as result.template;"
+                    + " write it as result.template in " + configFile.getName());
+        }
         if (result.hasTemplate()) {
             String templateId = ResultRef.templateId(result.getTemplateRef());
             if (TemplateLoader.getById(templateId) == null) {
diff --git a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
index 782a62a..144c5fd 100644
--- a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
+++ b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
@@ -48,6 +48,7 @@
 import net.tfminecraft.research.util.ItemRef;
 import net.tfminecraft.research.util.OutputPicker;
 import net.tfminecraft.research.util.PlayerInventoryUtil;
+import net.tfminecraft.research.util.ResultRef;
 import net.tfminecraft.research.util.ResultResolver;
 import net.tfminecraft.research.util.ResultSpawnEffects;
 import net.tfminecraft.research.util.RevealHelper;
@@ -174,6 +175,7 @@ public void onStationInteract(PlayerInteractEvent event) {
                 return;
             }
             openMainGui(player, station);
+            finishIfAlreadyComplete(player, station);
             return;
         }
 
@@ -555,6 +557,21 @@ private boolean checkProjectCompletion(Player player, ResearchStation station, O
                     + "' has no resolved result on active project.");
             return false;
         }
+        if (ResultRef.isTemplateRef(resultRef)) {
+            // Projects started from result.item: t.<id> saved the template itself; roll it now.
+            String rolled = ResultResolver.resolveToItemRef(resultRef);
+            if (rolled == null) {
+                Research.plugin.getLogger().warning("[Research] Could not resolve saved result template '"
+                        + resultRef + "' for output '" + outputDef.getId() + "' at "
+                        + ResearchStation.locationKey(station.getLocation()));
+                return false;
+            }
+            Research.plugin.getLogger().info("[Research] Resolved saved result template '" + resultRef + "' to '"
+                    + rolled + "' for output '" + outputDef.getId() + "'.");
+            active.setResolvedResultRef(rolled);
+            StationStore.saveStation(station);
+            resultRef = rolled;
+        }
 
         ItemStack reward = ItemRef.build(resultRef);
         if (reward == null) {
@@ -646,7 +663,13 @@ private ResearchStation startProject(Player player, Location location, Equipment
         String outputId = OutputPicker.roll(input);
         OutputDef output = outputId != null ? OutputLoader.getById(outputId) : null;
         if (output == null || !output.isEnabled()) {
-            player.sendMessage(Messages.get("reload.failed"));
+            refuseStart(player, input, outputId == null ? "has no outputs"
+                    : "rolled output '" + outputId + "', which is " + (output == null ? "not loaded" : "disabled"));
+            return null;
+        }
+        if (!OutputLoader.passedChecks(output.getId())) {
+            refuseStart(player, input, "rolled output '" + output.getId()
+                    + "', which failed its load checks (see the errors from the last load); fix it and run /research reload");
             return null;
         }
 
@@ -654,7 +677,7 @@ private ResearchStation startProject(Player player, Location location, Equipment
         if (resolvedResultRef == null) {
             Research.plugin.getLogger().severe("[Research] Could not resolve result for output '" + output.getId()
                     + "' at station start.");
-            player.sendMessage(Messages.get("reload.failed"));
+            refuseStart(player, input, "could not resolve the result of output '" + output.getId() + "'");
             return null;
         }
 
@@ -674,6 +697,14 @@ private ResearchStation startProject(Player player, Location location, Equipment
         return station;
     }
 
+    /** A configuration problem stops the start before the research paper is taken. */
+    private void refuseStart(Player player, InputDef input, String problem) {
+        Research.plugin.getLogger().warning("[Research] " + player.getName() + " could not start research '"
+                + input.getId() + "': it " + problem + ".");
+        player.sendMessage(Messages.getOrDefault("station.output_unavailable",
+                "#c45749This research cannot be started right now. Please tell a staff member."));
+    }
+
     private boolean tryConsumeStartItemFromHand(Player player, EquipmentSlot hand, InputDef inputDef) {
         return PlayerInventoryUtil.consumeFromHand(
                 player,
@@ -709,6 +740,21 @@ private void openMainGui(Player player, ResearchStation station) {
         inventoryManager.openMain(player, station);
     }
 
+    /**
+     * A project whose recipe is already complete but whose reward could not be given (such as a saved
+     * {@code t.*} template result) finishes when its owner opens it again, without another experiment.
+     */
+    private void finishIfAlreadyComplete(Player player, ResearchStation station) {
+        OutputDef outputDef = OutputLoader.getById(station.getProject().getResolvedOutputId());
+        InventoryView view = player.getOpenInventory();
+        if (outputDef == null || station.getProject().isCompleted()
+                || !(view.getTopInventory().getHolder() instanceof StationMenuHolder holder)
+                || !holder.isCurrent(player) || !isMenuFor(view, station)) {
+            return;
+        }
+        checkProjectCompletion(player, station, outputDef, view.getTopInventory());
+    }
+
     /**
      * Resolves the station a research menu was opened for. Each menu carries its lectern location,
      * so a player with several stations only ever acts on the one whose menu is open.
diff --git a/src/main/java/net/tfminecraft/research/model/ActiveProject.java b/src/main/java/net/tfminecraft/research/model/ActiveProject.java
index baacd5e..90f75c9 100644
--- a/src/main/java/net/tfminecraft/research/model/ActiveProject.java
+++ b/src/main/java/net/tfminecraft/research/model/ActiveProject.java
@@ -17,7 +17,7 @@ public final class ActiveProject {
 
     private final String inputId;
     private final String resolvedOutputId;
-    private final String resolvedResultRef;
+    private String resolvedResultRef;
     private boolean productRevealed;
     private boolean completed;
     private final Map<String, String> aspectStates = new HashMap<>();
@@ -55,6 +55,11 @@ public String getResolvedResultRef() {
         return resolvedResultRef;
     }
 
+    /** Replaces a saved result that was still a template ref with the item it rolled. */
+    public void setResolvedResultRef(String resolvedResultRef) {
+        this.resolvedResultRef = resolvedResultRef;
+    }
+
     /**
      * @deprecated Use {@link #getResolvedOutputId()} for the output-centric model.
      */
diff --git a/src/main/java/net/tfminecraft/research/model/OutputDef.java b/src/main/java/net/tfminecraft/research/model/OutputDef.java
index cb6da6a..368ee6b 100644
--- a/src/main/java/net/tfminecraft/research/model/OutputDef.java
+++ b/src/main/java/net/tfminecraft/research/model/OutputDef.java
@@ -11,6 +11,8 @@
 
 import org.bukkit.configuration.ConfigurationSection;
 
+import net.tfminecraft.research.util.ResultRef;
+
 public final class OutputDef {
 
     private final String id;
@@ -156,15 +158,20 @@ private static Map<String, AspectRequirement> readAspects(ConfigurationSection s
     public static final class ResultSpec {
         private final String itemRef;
         private final String templateRef;
+        private final boolean templateInItemKey;
 
         public ResultSpec(ConfigurationSection config) {
-            if (config != null) {
-                this.itemRef = config.getString("item", "");
-                this.templateRef = config.getString("template", "");
-            } else {
-                this.itemRef = "";
-                this.templateRef = "";
-            }
+            String item = config != null ? config.getString("item", "") : "";
+            String template = config != null ? config.getString("template", "") : "";
+            // result.item: t.<id> is a template written under the wrong key; read it as result.template.
+            this.templateInItemKey = ResultRef.isTemplateRef(item) && (template == null || template.isBlank());
+            this.itemRef = templateInItemKey ? "" : item;
+            this.templateRef = templateInItemKey ? item : template;
+        }
+
+        /** True when the template was written as {@code result.item: t.<id>} instead of {@code result.template}. */
+        public boolean isTemplateInItemKey() {
+            return templateInItemKey;
         }
 
         public String getItemRef() {
diff --git a/src/main/java/net/tfminecraft/research/util/ResultResolver.java b/src/main/java/net/tfminecraft/research/util/ResultResolver.java
index 7796568..ad99d07 100644
--- a/src/main/java/net/tfminecraft/research/util/ResultResolver.java
+++ b/src/main/java/net/tfminecraft/research/util/ResultResolver.java
@@ -25,7 +25,11 @@ public static String resolve(OutputDef.ResultSpec result) {
         return null;
     }
 
-    private static String resolveToItemRef(String ref) {
+    /**
+     * Rolls a saved or configured result down to an item ref: a {@code t.*} template is rolled (nested
+     * templates too), an item ref is returned as it is, and anything else gives null.
+     */
+    public static String resolveToItemRef(String ref) {
         if (ref == null || ref.isBlank()) {
             return null;
         }
diff --git a/src/main/resources/messages.yml b/src/main/resources/messages.yml
index d538677..960ebb2 100644
--- a/src/main/resources/messages.yml
+++ b/src/main/resources/messages.yml
@@ -15,6 +15,7 @@ station:
   hold_start_item: "#c45749Hold a research paper in your hand to use this station."
   invalid_start_item: "#c45749That item cannot start a research project."
   missing_start_item: "#c45749You need that research paper in your hand to start."
+  output_unavailable: "#c45749This research cannot be started right now. Please tell a staff member."
   scrapped: "#c45749Research project scrapped."
   broken: "#c45749Research at this lectern was destroyed."
   scrap_warning: "#c45749WARNING! #ff5555The project will not be refunded!"
diff --git a/src/test/java/net/tfminecraft/research/ResearchTestState.java b/src/test/java/net/tfminecraft/research/ResearchTestState.java
index 76f31e9..e4a5e3f 100644
--- a/src/test/java/net/tfminecraft/research/ResearchTestState.java
+++ b/src/test/java/net/tfminecraft/research/ResearchTestState.java
@@ -6,7 +6,9 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.Map;
+import java.util.Set;
 
 /** Restores process-wide configuration and registries after an isolated test. */
 public final class ResearchTestState implements AutoCloseable {
@@ -21,6 +23,7 @@ public ResearchTestState() throws IllegalAccessException {
                 Object value = field.get(null);
                 if (Modifier.isFinal(field.getModifiers())) {
                     if (value instanceof Map<?, ?> map) values.put(field, new LinkedHashMap<>(map));
+                    else if (value instanceof Set<?> set) values.put(field, new LinkedHashSet<>(set));
                 } else {
                     values.put(field, value);
                 }
@@ -32,7 +35,11 @@ public ResearchTestState() throws IllegalAccessException {
     @SuppressWarnings("unchecked")
     public void close() throws IllegalAccessException {
         for (var saved : values.entrySet()) {
-            if (Modifier.isFinal(saved.getKey().getModifiers())) {
+            if (saved.getValue() instanceof Set<?> set && Modifier.isFinal(saved.getKey().getModifiers())) {
+                Set<Object> live = (Set<Object>) saved.getKey().get(null);
+                live.clear();
+                live.addAll(set);
+            } else if (Modifier.isFinal(saved.getKey().getModifiers())) {
                 Map<Object, Object> map = (Map<Object, Object>) saved.getKey().get(null);
                 map.clear();
                 map.putAll((Map<Object, Object>) saved.getValue());
diff --git a/src/test/java/net/tfminecraft/research/ResearchTextAndModelTest.java b/src/test/java/net/tfminecraft/research/ResearchTextAndModelTest.java
index 879a023..e912890 100644
--- a/src/test/java/net/tfminecraft/research/ResearchTextAndModelTest.java
+++ b/src/test/java/net/tfminecraft/research/ResearchTextAndModelTest.java
@@ -39,6 +39,11 @@ class ResearchTextAndModelTest {
         for (var style : GuiText.AspectNameStyle.values()) assertEquals("name",ChatColor.stripColor(GuiText.aspectName(style,"§aname")));
         assertEquals("",GuiText.aspectName(GuiText.AspectNameStyle.PLAIN,null));
     }
+    @Test void messagesMissingFromAnOlderMessagesFileUseTheirFallbackWithThePrefix() {
+        Messages.clear(); Messages.setPrefix("[Research] "); Messages.put("station.output_unavailable", "Configured");
+        assertEquals("[Research] Configured", Messages.getOrDefault("station.output_unavailable", "Fallback"));
+        assertEquals("[Research] Fallback", Messages.getOrDefault("station.absent", "Fallback"));
+    }
     @Test void completionEventPublishesStablePluginApi() {
         var player = org.mockito.Mockito.mock(org.bukkit.entity.Player.class);
         var event = new net.tfminecraft.research.event.ResearchCompleteEvent(player,"input","output","v.paper");
diff --git a/src/test/java/net/tfminecraft/research/loader/ResearchLoadersTest.java b/src/test/java/net/tfminecraft/research/loader/ResearchLoadersTest.java
index ee4ee0a..838dbf9 100644
--- a/src/test/java/net/tfminecraft/research/loader/ResearchLoadersTest.java
+++ b/src/test/java/net/tfminecraft/research/loader/ResearchLoadersTest.java
@@ -222,6 +222,50 @@ void outputValidationChecksDisplaysAspectsAndExclusiveResultKinds() throws Excep
         assertNotNull(OutputLoader.getById("single"));
     }
 
+    @Test
+    void templateWrittenAsResultItemLoadsAsATemplateWithAWarning() throws Exception {
+        TemplateLoader.get().put("loot", new ResultTemplateDef("loot", List.of(new ResultTemplateDef.WeightedOutput("v.paper", 1))));
+        File file = yaml("alias-outputs/a.yml", """
+                alias:
+                  mystery_display: {item: v.paper}
+                  product_display: {item: v.paper}
+                  result: {item: " t.loot "}
+                alias-and-template:
+                  mystery_display: {item: v.paper}
+                  product_display: {item: v.paper}
+                  result: {item: t.loot, template: t.loot}
+                """);
+
+        assertFalse(new OutputLoader().loadFolder(file.getParentFile()));
+
+        OutputDef.ResultSpec alias = OutputLoader.getById("alias").getResult();
+        assertTrue(alias.isTemplateInItemKey());
+        assertTrue(alias.hasTemplate());
+        assertFalse(alias.hasItem());
+        assertTrue(OutputLoader.passedChecks("alias"));
+        verify(logger).warning(contains("Output 'alias' sets result.item: t.loot, which is a template."
+                + " It is read as result.template; write it as result.template in a.yml"));
+        OutputDef.ResultSpec both = OutputLoader.getById("alias-and-template").getResult();
+        assertFalse(both.isTemplateInItemKey());
+        assertTrue(both.hasItem() && both.hasTemplate());
+        assertFalse(OutputLoader.passedChecks("alias-and-template"));
+        assertEquals(java.util.Set.of("alias-and-template"), OutputLoader.failedChecks());
+    }
+
+    @Test
+    void outputsThatFailTheirChecksAreListedUntilTheNextLoad() throws Exception {
+        File bad = yaml("checked-bad/a.yml", "broken: {mystery_display: {item: v.paper}, product_display: {item: v.paper}, result: {item: t.missing}}\n");
+        assertFalse(new OutputLoader().loadFolder(bad.getParentFile()));
+        assertNotNull(OutputLoader.getById("broken"));
+        assertFalse(OutputLoader.passedChecks("broken"));
+        verify(logger).severe(contains("Output 'broken' references unknown template 'missing'"));
+
+        File good = yaml("checked-good/a.yml", "broken: {mystery_display: {item: v.paper}, product_display: {item: v.paper}, result: {item: v.paper}}\n");
+        assertTrue(new OutputLoader().loadFolder(good.getParentFile()));
+        assertTrue(OutputLoader.passedChecks("broken"));
+        assertTrue(OutputLoader.failedChecks().isEmpty());
+    }
+
     @Test
     void outputAspectPoolsLoadAndValidatePickSizeOverlapAndRows() throws Exception {
         for (String id : List.of("fire", "water", "earth", "air")) AspectLoader.get().put(id, new AspectDef(id, config("{}")));
diff --git a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
index 46db82a..9b6190d 100644
--- a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
+++ b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
@@ -60,6 +60,7 @@
 import net.tfminecraft.research.event.ResearchCompleteEvent;
 import net.tfminecraft.research.loader.AspectLoader;
 import net.tfminecraft.research.loader.OutputLoader;
+import net.tfminecraft.research.loader.TemplateLoader;
 import net.tfminecraft.research.model.ActiveProject;
 import net.tfminecraft.research.model.AspectDef;
 import net.tfminecraft.research.model.AspectState;
@@ -67,6 +68,7 @@
 import net.tfminecraft.research.model.InputDef;
 import net.tfminecraft.research.model.OutputDef;
 import net.tfminecraft.research.model.ResearchStation;
+import net.tfminecraft.research.model.ResultTemplateDef;
 import net.tfminecraft.research.registry.AspectItemRegistry;
 import net.tfminecraft.research.util.GridLayout;
 import net.tfminecraft.research.util.InputMatcher;
@@ -81,6 +83,7 @@ class ResearchManagerTest {
     private final List<AutoCloseable> mocks = new ArrayList<>();
     private final Map<Field, Object> originalCache = new LinkedHashMap<>();
     private Map<String, OutputDef> originalOutputs;
+    private Map<String, ResultTemplateDef> originalTemplates;
     private Map<String, AspectDef> originalAspects;
     private Research originalPlugin;
     private ResearchManager originalManager;
@@ -124,6 +127,9 @@ void setUp() throws Exception {
             originalCache.put(field, field.get(null));
         }
         originalOutputs = new LinkedHashMap<>(OutputLoader.get());
+        originalTemplates = new LinkedHashMap<>(TemplateLoader.get());
+        TemplateLoader.get().clear();
+        OutputLoader.failedChecks().clear();
         originalAspects = new LinkedHashMap<>(AspectLoader.get());
         OutputLoader.get().clear();
         AspectLoader.get().clear();
@@ -219,6 +225,7 @@ void setUp() throws Exception {
         sounds = scoped(mockStatic(SoundKeys.class));
         messages = scoped(mockStatic(Messages.class));
         messages.when(() -> Messages.get(anyString())).thenAnswer(call -> call.getArgument(0));
+        messages.when(() -> Messages.getOrDefault(anyString(), anyString())).thenAnswer(call -> call.getArgument(0));
         messages.when(() -> Messages.format(anyString(), anyMap()))
                 .thenAnswer(call -> call.getArgument(0) + " " + call.getArgument(1));
         scoped(mockStatic(MmoAttributes.class));
@@ -241,6 +248,9 @@ void restoreState() throws Exception {
         }
         OutputLoader.get().clear();
         OutputLoader.get().putAll(originalOutputs);
+        OutputLoader.failedChecks().clear();
+        TemplateLoader.get().clear();
+        TemplateLoader.get().putAll(originalTemplates);
         AspectLoader.get().clear();
         AspectLoader.get().putAll(originalAspects);
         Research.plugin = originalPlugin;
@@ -612,7 +622,7 @@ void onlyDrawnPoolAspectsCountTowardTheRecipe() {
     }
 
     @ParameterizedTest
-    @ValueSource(strings = {"unknown-output", "disabled", "unresolved", "missing-item"})
+    @ValueSource(strings = {"unknown-output", "disabled", "failed-checks", "unresolved", "missing-item"})
     void startFailuresDoNotCreateOrConsumeAProject(String failure) {
         noStations();
         ItemStack held = stack(Material.PAPER, 1);
@@ -624,12 +634,21 @@ void startFailuresDoNotCreateOrConsumeAProject(String failure) {
         if (failure.equals("disabled")) config.set("enabled", false);
         if (failure.equals("unresolved")) config.set("result", null);
         if (!failure.equals("unknown-output")) OutputLoader.get().put("output", new OutputDef("output", config));
+        if (failure.equals("failed-checks")) OutputLoader.failedChecks().add("output");
 
         manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
 
         assertNull(manager.getStationAt(location));
         assertEquals(1, held.getAmount());
-        verify(player).sendMessage(failure.equals("missing-item") ? "station.missing_start_item" : "reload.failed");
+        verify(player).sendMessage(failure.equals("missing-item") ? "station.missing_start_item" : "station.output_unavailable");
+        if (!failure.equals("missing-item")) {
+            verify(logger).warning(contains("Researcher could not start research 'input': it " + switch (failure) {
+                case "unknown-output" -> "rolled output 'output', which is not loaded.";
+                case "disabled" -> "rolled output 'output', which is disabled.";
+                case "failed-checks" -> "rolled output 'output', which failed its load checks";
+                default -> "could not resolve the result of output 'output'.";
+            }));
+        }
         store.verify(() -> StationStore.saveStation(any()), never());
         startEffects.verifyNoInteractions();
     }
@@ -836,7 +855,8 @@ void inputWithoutAnyOutputsFailsBeforeConsumingTheStartItem() {
         manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
 
         assertNull(manager.getStationAt(location));
-        verify(player).sendMessage("reload.failed");
+        verify(player).sendMessage("station.output_unavailable");
+        verify(logger).warning(contains("could not start research 'input': it has no outputs."));
         assertEquals(1, held.getAmount());
     }
 
@@ -1227,6 +1247,102 @@ void completionListenerCannotCloseAReplacementMenu(boolean switchesCharacter) {
         completeEffects.verify(() -> StationCompleteEffects.play(player, location), times(switchesCharacter ? 0 : 1));
     }
 
+    @Test
+    void savedTemplateResultIsRolledSavedAndGrantedAtCompletion() {
+        prepareExperiment("fire", null, Map.of("fire", 2));
+        project = new ActiveProject("input", "output", "t.greater_runestone");
+        station.setProject(project);
+        TemplateLoader.get().put("greater_runestone", new ResultTemplateDef("greater_runestone",
+                List.of(new ResultTemplateDef.WeightedOutput("m.loot.rune", 1))));
+        items.when(() -> ItemRef.hasKnownPrefix("m.loot.rune")).thenReturn(true);
+        ItemStack reward = stack(Material.PAPER, 1);
+        items.when(() -> ItemRef.build("m.loot.rune")).thenReturn(reward);
+        rewards.when(() -> ResultSpawnEffects.spawnAtStation(location, reward)).thenReturn(true);
+        List<String> savedRefs = new ArrayList<>();
+        store.when(() -> StationStore.saveStation(station)).thenAnswer(call -> {
+            savedRefs.add(station.getProject().getResolvedResultRef()); return true;
+        });
+
+        confirm();
+
+        assertTrue(project.isCompleted());
+        assertEquals("m.loot.rune", project.getResolvedResultRef());
+        assertEquals(List.of("m.loot.rune"), savedRefs);
+        assertNull(manager.getStationAt(location));
+        verify(logger).info(contains("Resolved saved result template 't.greater_runestone' to 'm.loot.rune'"));
+        ArgumentCaptor<ResearchCompleteEvent> event = ArgumentCaptor.forClass(ResearchCompleteEvent.class);
+        verify(pluginManager).callEvent(event.capture());
+        assertEquals("m.loot.rune", event.getValue().getResultItemRef());
+        store.verify(() -> StationStore.deleteStation(location));
+    }
+
+    @Test
+    void savedTemplateThatNoLongerExistsKeepsTheProjectAndExplainsWhy() {
+        prepareExperiment("fire", null, Map.of("fire", 2));
+        project = new ActiveProject("input", "output", "t.gone");
+        station.setProject(project);
+
+        confirm();
+
+        assertFalse(project.isCompleted());
+        assertEquals("t.gone", project.getResolvedResultRef());
+        assertSame(station, manager.getStationAt(location));
+        verify(logger).warning(contains("Could not resolve saved result template 't.gone' for output 'output' at "
+                + ResearchStation.locationKey(location)));
+        items.verify(() -> ItemRef.build(anyString()), never());
+        verifyNoInteractions(pluginManager);
+    }
+
+    @Test
+    void reopeningAProjectWhoseRecipeIsAlreadyCompleteFinishesIt() {
+        output(Map.of("fire", 2));
+        project = new ActiveProject("input", "output", "t.greater_runestone");
+        project.setAspectState("fire", AspectState.CONFIRMED);
+        project.addAspectPoints("fire", 2, 2);
+        station.setProject(project);
+        TemplateLoader.get().put("greater_runestone", new ResultTemplateDef("greater_runestone",
+                List.of(new ResultTemplateDef.WeightedOutput("m.loot.rune", 1))));
+        items.when(() -> ItemRef.hasKnownPrefix("m.loot.rune")).thenReturn(true);
+        ItemStack reward = stack(Material.PAPER, 1);
+        items.when(() -> ItemRef.build("m.loot.rune")).thenReturn(reward);
+        rewards.when(() -> ResultSpawnEffects.spawnAtStation(location, reward)).thenReturn(true);
+
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+
+        verify(menus).openMain(player, station);
+        assertTrue(project.isCompleted());
+        assertNull(manager.getStationAt(location));
+        verify(player).sendMessage("station.completed");
+        store.verify(() -> StationStore.deleteStation(location));
+        completeEffects.verify(() -> StationCompleteEffects.play(player, location));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"incomplete", "no-output", "already-completed", "foreign-menu", "other-station", "stale-menu"})
+    void reopeningOnlyFinishesACompleteProjectThroughItsOwnMenu(String situation) {
+        output(Map.of("fire", 2));
+        if (!situation.equals("incomplete")) {
+            project.setAspectState("fire", AspectState.CONFIRMED);
+            project.addAspectPoints("fire", 2, 2);
+        }
+        if (situation.equals("no-output")) OutputLoader.get().clear();
+        if (situation.equals("already-completed")) project.setCompleted(true);
+        if (situation.equals("foreign-menu")) when(top.getHolder()).thenReturn(null);
+        if (situation.equals("other-station")) {
+            when(top.getHolder()).thenReturn(new StationMenuHolder(location.clone().add(5, 0, 0), session));
+        }
+        if (situation.equals("stale-menu")) {
+            when(top.getHolder()).thenReturn(new StationMenuHolder(location, new CharacterSession(session.ref(), 9)));
+        }
+
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+
+        verify(menus).openMain(player, station);
+        assertSame(station, manager.getStationAt(location));
+        items.verify(() -> ItemRef.build(anyString()), never());
+        store.verify(() -> StationStore.deleteStation(any()), never());
+    }
+
     private ItemStack prepareExperiment(String primary, String secondary, Map<String, Integer> recipe) {
         output(recipe);
         ItemStack item = stack(Material.COAL, 1);
diff --git a/src/test/java/net/tfminecraft/research/util/ResearchUtilitiesTest.java b/src/test/java/net/tfminecraft/research/util/ResearchUtilitiesTest.java
index ed3f231..60b97a0 100644
--- a/src/test/java/net/tfminecraft/research/util/ResearchUtilitiesTest.java
+++ b/src/test/java/net/tfminecraft/research/util/ResearchUtilitiesTest.java
@@ -361,6 +361,21 @@ void directResultsAreTrimmedAndMissingResultsReturnNull() {
         assertEquals("vanilla.PAPER", ResultResolver.resolve(new OutputDef.ResultSpec(config)));
     }
 
+    @Test
+    void templateWrittenAsResultItemResolvesLikeAResultTemplate() {
+        TemplateLoader.get().put("loot", new ResultTemplateDef("loot", List.of(
+                new ResultTemplateDef.WeightedOutput("vanilla.EMERALD", 1))));
+        YamlConfiguration config = new YamlConfiguration();
+        config.set("item", "t.loot");
+        OutputDef.ResultSpec spec = new OutputDef.ResultSpec(config);
+        assertTrue(spec.isTemplateInItemKey());
+        assertEquals("vanilla.EMERALD", ResultResolver.resolve(spec));
+        assertEquals("vanilla.EMERALD", ResultResolver.resolveToItemRef("t.loot"));
+        assertEquals("vanilla.PAPER", ResultResolver.resolveToItemRef("vanilla.PAPER"));
+        assertNull(ResultResolver.resolveToItemRef("t.absent"));
+        assertNull(ResultResolver.resolveToItemRef("not-an-item"));
+    }
+
     @Test
     void controlOnlyDirectResultsAreRejectedAfterTrimming() throws Exception {
         YamlConfiguration config = new YamlConfiguration();

From e7bde2a5bc59e23e71e749883ec7b866fe547cb6 Mon Sep 17 00:00:00 2001
From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 16:53:03 +0100
Subject: [PATCH 2/6] fix: address review on template results and refused
 starts

- Roll a saved template, build the reward, and only then save the rolled
  ref, so a roll that cannot be built never pins the station; warn when
  that save fails.
- Outputs with no aspects and no aspect_pool.pick now fail their load
  checks (no live Main, Dev or Tutorial output has one), and the reopen
  finish skips outputs that failed their checks or have an empty recipe.
- The reopen finish runs for the main hand only and tells the player when
  the reward still cannot be given.
- Refused starts are logged once per input and output until the next
  load, with no second log for an unresolved result.
- OutputLoader.failedChecks() is read-only; tests use a package hook.
- station.output_unavailable now reads "This research is not working
  right now", since it also covers a reward that cannot be given.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../research/loader/OutputLoader.java         |  28 +++-
 .../research/manager/ResearchManager.java     |  75 +++++++----
 src/main/resources/messages.yml               |   2 +-
 .../research/loader/OutputChecks.java         |  15 +++
 .../research/loader/ResearchLoadersTest.java  |  28 +++-
 .../research/manager/ResearchManagerTest.java | 122 +++++++++++++++++-
 6 files changed, 235 insertions(+), 35 deletions(-)
 create mode 100644 src/test/java/net/tfminecraft/research/loader/OutputChecks.java

diff --git a/src/main/java/net/tfminecraft/research/loader/OutputLoader.java b/src/main/java/net/tfminecraft/research/loader/OutputLoader.java
index 78f1c35..cc95f34 100644
--- a/src/main/java/net/tfminecraft/research/loader/OutputLoader.java
+++ b/src/main/java/net/tfminecraft/research/loader/OutputLoader.java
@@ -3,6 +3,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -27,6 +28,7 @@ public final class OutputLoader implements LoaderInterface {
 
     private static final Map<String, OutputDef> map = new LinkedHashMap<>();
     private static final Set<String> failedChecks = new HashSet<>();
+    private static final Set<String> refusalsLogged = new HashSet<>();
 
     public static Map<String, OutputDef> get() {
         return map;
@@ -34,13 +36,29 @@ public static Map<String, OutputDef> get() {
 
     /** Ids of loaded outputs that failed a load check. They stay listed, but no project can start them. */
     public static Set<String> failedChecks() {
-        return failedChecks;
+        return Collections.unmodifiableSet(failedChecks);
     }
 
     public static boolean passedChecks(String id) {
         return !failedChecks.contains(id);
     }
 
+    /** True the first time a refused start is reported for this key since the last load, so the console is not flooded. */
+    public static boolean firstRefusal(String key) {
+        return refusalsLogged.add(key);
+    }
+
+    /** Test hook: marks an output as failed without loading a file. */
+    static void markFailed(String id) {
+        failedChecks.add(id);
+    }
+
+    /** Test hook: forgets failed outputs and logged refusals, as a load does. */
+    static void resetChecks() {
+        failedChecks.clear();
+        refusalsLogged.clear();
+    }
+
     public static OutputDef getById(String id) {
         return map.get(id);
     }
@@ -52,7 +70,7 @@ public void load(File configFile) {
 
     public boolean loadFolder(File folder) {
         map.clear();
-        failedChecks.clear();
+        resetChecks();
         boolean ok = true;
         List<File> files = new ArrayList<>(YamlFolder.listYamlFiles(folder));
         files.sort(Comparator.comparing(file -> file.getName().toLowerCase()));
@@ -111,6 +129,12 @@ private boolean validate(OutputDef def, File configFile) {
                     + GridLayout.ASPECT_ROW_COUNT + " in " + configFile.getName());
             ok = false;
         }
+        if (recipeSize <= 0) {
+            // A recipe with nothing to research would be complete the moment it starts.
+            Research.plugin.getLogger().severe("[Research] Output '" + def.getId()
+                    + "' lists no aspects and no aspect_pool.pick in " + configFile.getName());
+            ok = false;
+        }
 
         ok &= validateAspects(def.getId(), "", def.getAspects(), configFile);
         ok &= validateAspectPool(def, configFile);
diff --git a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
index 144c5fd..fd4fd83 100644
--- a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
+++ b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
@@ -65,6 +65,10 @@ public final class ResearchManager implements Listener {
     private final PlayerManager playerManager;
     private final InventoryManager inventoryManager;
 
+    /** Fallback for station.output_unavailable until an older messages.yml gets the key. */
+    static final String OUTPUT_UNAVAILABLE =
+            "#c45749This research is not working right now. Please tell a staff member.";
+
     private final List<ResearchStation> stations = new ArrayList<>();
 
     public ResearchManager(PlayerManager playerManager) {
@@ -175,7 +179,9 @@ public void onStationInteract(PlayerInteractEvent event) {
                 return;
             }
             openMainGui(player, station);
-            finishIfAlreadyComplete(player, station);
+            if (hand == EquipmentSlot.HAND) {
+                finishIfAlreadyComplete(player, station);
+            }
             return;
         }
 
@@ -557,28 +563,36 @@ private boolean checkProjectCompletion(Player player, ResearchStation station, O
                     + "' has no resolved result on active project.");
             return false;
         }
-        if (ResultRef.isTemplateRef(resultRef)) {
+        String savedRef = resultRef;
+        if (ResultRef.isTemplateRef(savedRef)) {
             // Projects started from result.item: t.<id> saved the template itself; roll it now.
-            String rolled = ResultResolver.resolveToItemRef(resultRef);
-            if (rolled == null) {
+            resultRef = ResultResolver.resolveToItemRef(savedRef);
+            if (resultRef == null) {
                 Research.plugin.getLogger().warning("[Research] Could not resolve saved result template '"
-                        + resultRef + "' for output '" + outputDef.getId() + "' at "
+                        + savedRef + "' for output '" + outputDef.getId() + "' at "
                         + ResearchStation.locationKey(station.getLocation()));
                 return false;
             }
-            Research.plugin.getLogger().info("[Research] Resolved saved result template '" + resultRef + "' to '"
-                    + rolled + "' for output '" + outputDef.getId() + "'.");
-            active.setResolvedResultRef(rolled);
-            StationStore.saveStation(station);
-            resultRef = rolled;
         }
 
         ItemStack reward = ItemRef.build(resultRef);
         if (reward == null) {
             Research.plugin.getLogger().warning("[Research] Could not build result item for output '"
-                    + outputDef.getId() + "': " + resultRef);
+                    + outputDef.getId() + "': " + resultRef
+                    + (resultRef.equals(savedRef) ? "" : " (rolled from saved template '" + savedRef + "', kept)"));
             return false;
         }
+        if (!resultRef.equals(savedRef)) {
+            // Only a roll that builds replaces the saved template, so a bad roll cannot pin the station.
+            Research.plugin.getLogger().info("[Research] Resolved saved result template '" + savedRef + "' to '"
+                    + resultRef + "' for output '" + outputDef.getId() + "'.");
+            active.setResolvedResultRef(resultRef);
+            if (!StationStore.saveStation(station)) {
+                Research.plugin.getLogger().warning("[Research] Could not save the rolled result '" + resultRef
+                        + "' for station " + ResearchStation.locationKey(station.getLocation())
+                        + "; it is kept in memory for the next save.");
+            }
+        }
 
         Location stationLoc = blockLocation(station.getLocation());
         if (!ResultSpawnEffects.spawnAtStation(stationLoc, reward)) {
@@ -663,21 +677,19 @@ private ResearchStation startProject(Player player, Location location, Equipment
         String outputId = OutputPicker.roll(input);
         OutputDef output = outputId != null ? OutputLoader.getById(outputId) : null;
         if (output == null || !output.isEnabled()) {
-            refuseStart(player, input, outputId == null ? "has no outputs"
+            refuseStart(player, input, outputId, outputId == null ? "has no outputs"
                     : "rolled output '" + outputId + "', which is " + (output == null ? "not loaded" : "disabled"));
             return null;
         }
         if (!OutputLoader.passedChecks(output.getId())) {
-            refuseStart(player, input, "rolled output '" + output.getId()
+            refuseStart(player, input, outputId, "rolled output '" + output.getId()
                     + "', which failed its load checks (see the errors from the last load); fix it and run /research reload");
             return null;
         }
 
         String resolvedResultRef = ResultResolver.resolve(output.getResult());
         if (resolvedResultRef == null) {
-            Research.plugin.getLogger().severe("[Research] Could not resolve result for output '" + output.getId()
-                    + "' at station start.");
-            refuseStart(player, input, "could not resolve the result of output '" + output.getId() + "'");
+            refuseStart(player, input, outputId, "could not resolve the result of output '" + output.getId() + "'");
             return null;
         }
 
@@ -697,12 +709,20 @@ private ResearchStation startProject(Player player, Location location, Equipment
         return station;
     }
 
-    /** A configuration problem stops the start before the research paper is taken. */
-    private void refuseStart(Player player, InputDef input, String problem) {
-        Research.plugin.getLogger().warning("[Research] " + player.getName() + " could not start research '"
-                + input.getId() + "': it " + problem + ".");
-        player.sendMessage(Messages.getOrDefault("station.output_unavailable",
-                "#c45749This research cannot be started right now. Please tell a staff member."));
+    /**
+     * A configuration problem stops the start before the research paper is taken. The console hears about
+     * each input and output pair once per load, not on every right-click.
+     */
+    private void refuseStart(Player player, InputDef input, String outputId, String problem) {
+        if (OutputLoader.firstRefusal(input.getId() + " -> " + outputId)) {
+            Research.plugin.getLogger().warning("[Research] " + player.getName() + " could not start research '"
+                    + input.getId() + "': it " + problem + ". Logged once until the next load.");
+        }
+        sendUnavailable(player);
+    }
+
+    private static void sendUnavailable(Player player) {
+        player.sendMessage(Messages.getOrDefault("station.output_unavailable", OUTPUT_UNAVAILABLE));
     }
 
     private boolean tryConsumeStartItemFromHand(Player player, EquipmentSlot hand, InputDef inputDef) {
@@ -745,14 +765,19 @@ private void openMainGui(Player player, ResearchStation station) {
      * {@code t.*} template result) finishes when its owner opens it again, without another experiment.
      */
     private void finishIfAlreadyComplete(Player player, ResearchStation station) {
-        OutputDef outputDef = OutputLoader.getById(station.getProject().getResolvedOutputId());
+        ActiveProject project = station.getProject();
+        OutputDef outputDef = OutputLoader.getById(project.getResolvedOutputId());
         InventoryView view = player.getOpenInventory();
-        if (outputDef == null || station.getProject().isCompleted()
+        // An output that failed its checks (an empty recipe among them) never finishes for free here.
+        if (outputDef == null || project.isCompleted() || !OutputLoader.passedChecks(outputDef.getId())
+                || outputDef.getRecipeAspects(project).isEmpty() || !isRecipeComplete(player, outputDef, project)
                 || !(view.getTopInventory().getHolder() instanceof StationMenuHolder holder)
                 || !holder.isCurrent(player) || !isMenuFor(view, station)) {
             return;
         }
-        checkProjectCompletion(player, station, outputDef, view.getTopInventory());
+        if (!checkProjectCompletion(player, station, outputDef, view.getTopInventory())) {
+            sendUnavailable(player);
+        }
     }
 
     /**
diff --git a/src/main/resources/messages.yml b/src/main/resources/messages.yml
index 960ebb2..f33dbb4 100644
--- a/src/main/resources/messages.yml
+++ b/src/main/resources/messages.yml
@@ -15,7 +15,7 @@ station:
   hold_start_item: "#c45749Hold a research paper in your hand to use this station."
   invalid_start_item: "#c45749That item cannot start a research project."
   missing_start_item: "#c45749You need that research paper in your hand to start."
-  output_unavailable: "#c45749This research cannot be started right now. Please tell a staff member."
+  output_unavailable: "#c45749This research is not working right now. Please tell a staff member."
   scrapped: "#c45749Research project scrapped."
   broken: "#c45749Research at this lectern was destroyed."
   scrap_warning: "#c45749WARNING! #ff5555The project will not be refunded!"
diff --git a/src/test/java/net/tfminecraft/research/loader/OutputChecks.java b/src/test/java/net/tfminecraft/research/loader/OutputChecks.java
new file mode 100644
index 0000000..b6f2f3f
--- /dev/null
+++ b/src/test/java/net/tfminecraft/research/loader/OutputChecks.java
@@ -0,0 +1,15 @@
+package net.tfminecraft.research.loader;
+
+/** Lets tests in other packages set which outputs failed their load checks. */
+public final class OutputChecks {
+
+    private OutputChecks() {}
+
+    public static void markFailed(String id) {
+        OutputLoader.markFailed(id);
+    }
+
+    public static void reset() {
+        OutputLoader.resetChecks();
+    }
+}
diff --git a/src/test/java/net/tfminecraft/research/loader/ResearchLoadersTest.java b/src/test/java/net/tfminecraft/research/loader/ResearchLoadersTest.java
index 838dbf9..01cfcbe 100644
--- a/src/test/java/net/tfminecraft/research/loader/ResearchLoadersTest.java
+++ b/src/test/java/net/tfminecraft/research/loader/ResearchLoadersTest.java
@@ -224,15 +224,18 @@ void outputValidationChecksDisplaysAspectsAndExclusiveResultKinds() throws Excep
 
     @Test
     void templateWrittenAsResultItemLoadsAsATemplateWithAWarning() throws Exception {
+        AspectLoader.get().put("fire", new AspectDef("fire", config("{}")));
         TemplateLoader.get().put("loot", new ResultTemplateDef("loot", List.of(new ResultTemplateDef.WeightedOutput("v.paper", 1))));
         File file = yaml("alias-outputs/a.yml", """
                 alias:
                   mystery_display: {item: v.paper}
                   product_display: {item: v.paper}
+                  aspects: {fire: {required_points: 1}}
                   result: {item: " t.loot "}
                 alias-and-template:
                   mystery_display: {item: v.paper}
                   product_display: {item: v.paper}
+                  aspects: {fire: {required_points: 1}}
                   result: {item: t.loot, template: t.loot}
                 """);
 
@@ -250,17 +253,38 @@ void templateWrittenAsResultItemLoadsAsATemplateWithAWarning() throws Exception
         assertTrue(both.hasItem() && both.hasTemplate());
         assertFalse(OutputLoader.passedChecks("alias-and-template"));
         assertEquals(java.util.Set.of("alias-and-template"), OutputLoader.failedChecks());
+        assertThrows(UnsupportedOperationException.class, () -> OutputLoader.failedChecks().add("x"));
+    }
+
+    @Test
+    void outputsWithNothingToResearchFailTheirChecks() throws Exception {
+        AspectLoader.get().put("fire", new AspectDef("fire", config("{}")));
+        File file = yaml("empty-recipe/a.yml", """
+                nothing: {mystery_display: {item: v.paper}, product_display: {item: v.paper}, result: {item: v.paper}}
+                fixed: {mystery_display: {item: v.paper}, product_display: {item: v.paper}, result: {item: v.paper}, aspects: {fire: {required_points: 1}}}
+                pooled: {mystery_display: {item: v.paper}, product_display: {item: v.paper}, result: {item: v.paper}, aspect_pool: {pick: 1, aspects: {fire: {required_points: 1}}}}
+                """);
+
+        assertFalse(new OutputLoader().loadFolder(file.getParentFile()));
+
+        assertEquals(java.util.Set.of("nothing"), OutputLoader.failedChecks());
+        verify(logger).severe(contains("Output 'nothing' lists no aspects and no aspect_pool.pick in a.yml"));
+        assertTrue(OutputLoader.firstRefusal("input -> nothing"));
+        assertFalse(OutputLoader.firstRefusal("input -> nothing"));
+        new OutputLoader().loadFolder(file.getParentFile());
+        assertTrue(OutputLoader.firstRefusal("input -> nothing"), "a load forgets logged refusals");
     }
 
     @Test
     void outputsThatFailTheirChecksAreListedUntilTheNextLoad() throws Exception {
-        File bad = yaml("checked-bad/a.yml", "broken: {mystery_display: {item: v.paper}, product_display: {item: v.paper}, result: {item: t.missing}}\n");
+        AspectLoader.get().put("fire", new AspectDef("fire", config("{}")));
+        File bad = yaml("checked-bad/a.yml", "broken: {mystery_display: {item: v.paper}, product_display: {item: v.paper}, aspects: {fire: {required_points: 1}}, result: {item: t.missing}}\n");
         assertFalse(new OutputLoader().loadFolder(bad.getParentFile()));
         assertNotNull(OutputLoader.getById("broken"));
         assertFalse(OutputLoader.passedChecks("broken"));
         verify(logger).severe(contains("Output 'broken' references unknown template 'missing'"));
 
-        File good = yaml("checked-good/a.yml", "broken: {mystery_display: {item: v.paper}, product_display: {item: v.paper}, result: {item: v.paper}}\n");
+        File good = yaml("checked-good/a.yml", "broken: {mystery_display: {item: v.paper}, product_display: {item: v.paper}, aspects: {fire: {required_points: 1}}, result: {item: v.paper}}\n");
         assertTrue(new OutputLoader().loadFolder(good.getParentFile()));
         assertTrue(OutputLoader.passedChecks("broken"));
         assertTrue(OutputLoader.failedChecks().isEmpty());
diff --git a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
index 9b6190d..8cf3b15 100644
--- a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
+++ b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
@@ -59,6 +59,7 @@
 import net.tfminecraft.research.database.StationStore;
 import net.tfminecraft.research.event.ResearchCompleteEvent;
 import net.tfminecraft.research.loader.AspectLoader;
+import net.tfminecraft.research.loader.OutputChecks;
 import net.tfminecraft.research.loader.OutputLoader;
 import net.tfminecraft.research.loader.TemplateLoader;
 import net.tfminecraft.research.model.ActiveProject;
@@ -129,7 +130,7 @@ void setUp() throws Exception {
         originalOutputs = new LinkedHashMap<>(OutputLoader.get());
         originalTemplates = new LinkedHashMap<>(TemplateLoader.get());
         TemplateLoader.get().clear();
-        OutputLoader.failedChecks().clear();
+        OutputChecks.reset();
         originalAspects = new LinkedHashMap<>(AspectLoader.get());
         OutputLoader.get().clear();
         AspectLoader.get().clear();
@@ -248,7 +249,7 @@ void restoreState() throws Exception {
         }
         OutputLoader.get().clear();
         OutputLoader.get().putAll(originalOutputs);
-        OutputLoader.failedChecks().clear();
+        OutputChecks.reset();
         TemplateLoader.get().clear();
         TemplateLoader.get().putAll(originalTemplates);
         AspectLoader.get().clear();
@@ -634,7 +635,7 @@ void startFailuresDoNotCreateOrConsumeAProject(String failure) {
         if (failure.equals("disabled")) config.set("enabled", false);
         if (failure.equals("unresolved")) config.set("result", null);
         if (!failure.equals("unknown-output")) OutputLoader.get().put("output", new OutputDef("output", config));
-        if (failure.equals("failed-checks")) OutputLoader.failedChecks().add("output");
+        if (failure.equals("failed-checks")) OutputChecks.markFailed("output");
 
         manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
 
@@ -1318,7 +1319,8 @@ void reopeningAProjectWhoseRecipeIsAlreadyCompleteFinishesIt() {
     }
 
     @ParameterizedTest
-    @ValueSource(strings = {"incomplete", "no-output", "already-completed", "foreign-menu", "other-station", "stale-menu"})
+    @ValueSource(strings = {"incomplete", "no-output", "already-completed", "failed-checks", "empty-recipe",
+            "foreign-menu", "other-station", "stale-menu", "off-hand"})
     void reopeningOnlyFinishesACompleteProjectThroughItsOwnMenu(String situation) {
         output(Map.of("fire", 2));
         if (!situation.equals("incomplete")) {
@@ -1326,6 +1328,8 @@ void reopeningOnlyFinishesACompleteProjectThroughItsOwnMenu(String situation) {
             project.addAspectPoints("fire", 2, 2);
         }
         if (situation.equals("no-output")) OutputLoader.get().clear();
+        if (situation.equals("failed-checks")) OutputChecks.markFailed("output");
+        if (situation.equals("empty-recipe")) output(Map.of());
         if (situation.equals("already-completed")) project.setCompleted(true);
         if (situation.equals("foreign-menu")) when(top.getHolder()).thenReturn(null);
         if (situation.equals("other-station")) {
@@ -1335,12 +1339,120 @@ void reopeningOnlyFinishesACompleteProjectThroughItsOwnMenu(String situation) {
             when(top.getHolder()).thenReturn(new StationMenuHolder(location, new CharacterSession(session.ref(), 9)));
         }
 
-        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern,
+                situation.equals("off-hand") ? EquipmentSlot.OFF_HAND : EquipmentSlot.HAND));
 
         verify(menus).openMain(player, station);
         assertSame(station, manager.getStationAt(location));
+        if (!situation.equals("already-completed")) assertFalse(project.isCompleted());
         items.verify(() -> ItemRef.build(anyString()), never());
         store.verify(() -> StationStore.deleteStation(any()), never());
+        verify(player, never()).sendMessage("station.output_unavailable");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"unbuildable", "spawn-failed"})
+    void reopeningACompleteProjectWhoseRewardFailsTellsThePlayer(String failure) {
+        output(Map.of("fire", 2));
+        project.setAspectState("fire", AspectState.CONFIRMED);
+        project.addAspectPoints("fire", 2, 2);
+        if (failure.equals("spawn-failed")) {
+            ItemStack reward = stack(Material.DIAMOND, 1);
+            items.when(() -> ItemRef.build("vanilla.DIAMOND")).thenReturn(reward);
+        }
+
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+
+        assertFalse(project.isCompleted());
+        assertSame(station, manager.getStationAt(location));
+        verify(player).sendMessage("station.output_unavailable");
+        verify(logger).warning(contains(failure.equals("unbuildable") ? "Could not build" : "Could not spawn"));
+        store.verify(() -> StationStore.deleteStation(any()), never());
+    }
+
+    @Test
+    void anotherPlayerCannotFinishACompleteProjectByOpeningIt() {
+        output(Map.of("fire", 2));
+        project.setAspectState("fire", AspectState.CONFIRMED);
+        project.addAspectPoints("fire", 2, 2);
+        station.setOwnerUuid(UUID.randomUUID());
+
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+
+        verify(player).sendMessage("station.in_use");
+        verifyNoInteractions(menus);
+        assertFalse(project.isCompleted());
+        items.verify(() -> ItemRef.build(anyString()), never());
+        store.verify(() -> StationStore.deleteStation(any()), never());
+    }
+
+    @Test
+    void aRolledTemplateThatCannotBeBuiltKeepsTheTemplateSaved() {
+        prepareExperiment("fire", null, Map.of("fire", 2));
+        project = new ActiveProject("input", "output", "t.greater_runestone");
+        station.setProject(project);
+        TemplateLoader.get().put("greater_runestone", new ResultTemplateDef("greater_runestone",
+                List.of(new ResultTemplateDef.WeightedOutput("m.loot.rune", 1))));
+        items.when(() -> ItemRef.hasKnownPrefix("m.loot.rune")).thenReturn(true);
+        List<String> savedRefs = new ArrayList<>();
+        store.when(() -> StationStore.saveStation(station)).thenAnswer(call -> {
+            savedRefs.add(station.getProject().getResolvedResultRef()); return true;
+        });
+
+        confirm();
+
+        assertFalse(project.isCompleted());
+        assertEquals("t.greater_runestone", project.getResolvedResultRef());
+        assertEquals(List.of("t.greater_runestone"), savedRefs);
+        verify(logger).warning(contains("Could not build result item for output 'output': m.loot.rune"
+                + " (rolled from saved template 't.greater_runestone', kept)"));
+        verify(logger, never()).info(contains("Resolved saved result template"));
+        verifyNoInteractions(pluginManager);
+    }
+
+    @Test
+    void aRolledResultThatCannotBeSavedIsStillGrantedAndLogged() {
+        prepareExperiment("fire", null, Map.of("fire", 2));
+        project = new ActiveProject("input", "output", "t.greater_runestone");
+        station.setProject(project);
+        TemplateLoader.get().put("greater_runestone", new ResultTemplateDef("greater_runestone",
+                List.of(new ResultTemplateDef.WeightedOutput("m.loot.rune", 1))));
+        items.when(() -> ItemRef.hasKnownPrefix("m.loot.rune")).thenReturn(true);
+        ItemStack reward = stack(Material.PAPER, 1);
+        items.when(() -> ItemRef.build("m.loot.rune")).thenReturn(reward);
+        rewards.when(() -> ResultSpawnEffects.spawnAtStation(location, reward)).thenReturn(true);
+        store.when(() -> StationStore.saveStation(station)).thenReturn(false);
+
+        confirm();
+
+        verify(logger).warning(contains("Could not save the rolled result 'm.loot.rune' for station "
+                + ResearchStation.locationKey(location) + "; it is kept in memory for the next save."));
+        assertTrue(project.isCompleted());
+        assertNull(manager.getStationAt(location));
+        store.verify(() -> StationStore.deleteStation(location));
+    }
+
+    @Test
+    void aRefusedStartIsLoggedOncePerInputAndOutputUntilTheNextLoad() {
+        noStations();
+        ItemStack held = stack(Material.PAPER, 1);
+        when(bottom.getItemInMainHand()).thenReturn(held);
+        inputs.when(() -> InputMatcher.findByStartItem(held)).thenReturn(input("vanilla.PAPER", 1, "output"));
+        output(Map.of("fire", 2));
+        OutputChecks.markFailed("output");
+
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+
+        verify(player, times(2)).sendMessage("station.output_unavailable");
+        verify(logger, times(1)).warning(contains("failed its load checks"));
+
+        OutputChecks.reset();
+        OutputChecks.markFailed("output");
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+
+        verify(logger, times(2)).warning(contains("failed its load checks"));
+        assertEquals(1, held.getAmount());
     }
 
     private ItemStack prepareExperiment(String primary, String secondary, Map<String, Integer> recipe) {

From b825e24b7d19535e39fff78e21b64cdbcd595049 Mon Sep 17 00:00:00 2001
From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 16:59:28 +0100
Subject: [PATCH 3/6] docs: clarify the rolled-result save warning and
 refusal-log state

Wording only: a failed save of a rolled result still gives the reward,
and OutputLoader notes that the refusal-log set is the manager's state,
main thread only and reset on each load.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../java/net/tfminecraft/research/loader/OutputLoader.java  | 6 +++++-
 .../net/tfminecraft/research/manager/ResearchManager.java   | 2 +-
 .../tfminecraft/research/manager/ResearchManagerTest.java   | 2 +-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/main/java/net/tfminecraft/research/loader/OutputLoader.java b/src/main/java/net/tfminecraft/research/loader/OutputLoader.java
index cc95f34..a1d01be 100644
--- a/src/main/java/net/tfminecraft/research/loader/OutputLoader.java
+++ b/src/main/java/net/tfminecraft/research/loader/OutputLoader.java
@@ -28,6 +28,7 @@ public final class OutputLoader implements LoaderInterface {
 
     private static final Map<String, OutputDef> map = new LinkedHashMap<>();
     private static final Set<String> failedChecks = new HashSet<>();
+    // ResearchManager's refused-start log state (see firstRefusal): main thread only, reset on each load.
     private static final Set<String> refusalsLogged = new HashSet<>();
 
     public static Map<String, OutputDef> get() {
@@ -43,7 +44,10 @@ public static boolean passedChecks(String id) {
         return !failedChecks.contains(id);
     }
 
-    /** True the first time a refused start is reported for this key since the last load, so the console is not flooded. */
+    /**
+     * True the first time a refused start is reported for this key since the last load, so the console is not
+     * flooded. Holds ResearchManager's refusal-log state; main thread only; reset on each load.
+     */
     public static boolean firstRefusal(String key) {
         return refusalsLogged.add(key);
     }
diff --git a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
index fd4fd83..dbb3a4c 100644
--- a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
+++ b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
@@ -590,7 +590,7 @@ private boolean checkProjectCompletion(Player player, ResearchStation station, O
             if (!StationStore.saveStation(station)) {
                 Research.plugin.getLogger().warning("[Research] Could not save the rolled result '" + resultRef
                         + "' for station " + ResearchStation.locationKey(station.getLocation())
-                        + "; it is kept in memory for the next save.");
+                        + "; the reward is still given.");
             }
         }
 
diff --git a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
index 8cf3b15..3d3c407 100644
--- a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
+++ b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
@@ -1426,7 +1426,7 @@ void aRolledResultThatCannotBeSavedIsStillGrantedAndLogged() {
         confirm();
 
         verify(logger).warning(contains("Could not save the rolled result 'm.loot.rune' for station "
-                + ResearchStation.locationKey(location) + "; it is kept in memory for the next save."));
+                + ResearchStation.locationKey(location) + "; the reward is still given."));
         assertTrue(project.isCompleted());
         assertNull(manager.getStationAt(location));
         store.verify(() -> StationStore.deleteStation(location));

From 2ff3ff3fea2b52a972aa01e58e89a658bd42b826 Mon Sep 17 00:00:00 2001
From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 22:19:50 +0100
Subject: [PATCH 4/6] fix: ignore the off-hand half of a click that finished a
 project

A real client sends an off-hand interact in the same tick when the main
hand did nothing client-side. After a main-hand reopen finished a project,
that off-hand half found the lectern free and started a new project from
a research paper held in the off hand (seen on Dev).

The manager now remembers the lectern and server tick of each player's
last main-hand reopen finish (one entry per player, dropped on the next
tick, on quit and on unload) and cancels only that player's off-hand
interact on the same lectern in the same tick. Off-hand starts on other
ticks or other lecterns work as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../research/manager/ResearchManager.java     | 41 ++++++++-
 .../research/manager/ResearchManagerTest.java | 86 +++++++++++++++++++
 2 files changed, 125 insertions(+), 2 deletions(-)

diff --git a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
index dbb3a4c..e3c531b 100644
--- a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
+++ b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
@@ -1,6 +1,7 @@
 package net.tfminecraft.research.manager;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
@@ -19,6 +20,7 @@
 import org.bukkit.event.inventory.InventoryCloseEvent;
 import org.bukkit.event.inventory.InventoryDragEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.inventory.EquipmentSlot;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryView;
@@ -70,6 +72,10 @@ public final class ResearchManager implements Listener {
             "#c45749This research is not working right now. Please tell a staff member.";
 
     private final List<ResearchStation> stations = new ArrayList<>();
+    /** At most one entry per online player: the lectern and tick of their last main-hand reopen finish. */
+    private final Map<UUID, FinishedClick> finishedClicks = new HashMap<>();
+
+    private record FinishedClick(String lecternKey, int tick) {}
 
     public ResearchManager(PlayerManager playerManager) {
         this.playerManager = playerManager;
@@ -96,6 +102,7 @@ public void unloadAll() {
         }
         StationStore.saveAll(stations);
         stations.clear();
+        finishedClicks.clear();
     }
 
     /** Every loaded station, read-only. */
@@ -157,9 +164,15 @@ public void onStationInteract(PlayerInteractEvent event) {
             return;
         }
 
+        EquipmentSlot hand = event.getHand() != null ? event.getHand() : EquipmentSlot.HAND;
+        if (isOffHandOfFinishingClick(player, hand, block)) {
+            // The main hand of this same click just finished a project here; don't start another from the off hand.
+            event.setCancelled(true);
+            return;
+        }
+
         Location stationLoc = block.getLocation();
         ResearchStation station = getStationAt(stationLoc);
-        EquipmentSlot hand = event.getHand() != null ? event.getHand() : EquipmentSlot.HAND;
         // A lectern with no project still places and opens written books.
         if (station == null && shouldLeaveLecternToVanilla(block, player, hand)) {
             return;
@@ -775,11 +788,35 @@ private void finishIfAlreadyComplete(Player player, ResearchStation station) {
                 || !holder.isCurrent(player) || !isMenuFor(view, station)) {
             return;
         }
-        if (!checkProjectCompletion(player, station, outputDef, view.getTopInventory())) {
+        if (checkProjectCompletion(player, station, outputDef, view.getTopInventory())) {
+            finishedClicks.put(player.getUniqueId(),
+                    new FinishedClick(ResearchStation.locationKey(station.getLocation()), Bukkit.getCurrentTick()));
+        } else {
             sendUnavailable(player);
         }
     }
 
+    /**
+     * A real client sends a second, off-hand interact in the same tick when the main hand did nothing on its side.
+     * After a main-hand reopen finished a project, that off-hand half must not start a new project on the freed lectern.
+     */
+    private boolean isOffHandOfFinishingClick(Player player, EquipmentSlot hand, Block block) {
+        FinishedClick click = finishedClicks.get(player.getUniqueId());
+        if (click == null) {
+            return false;
+        }
+        if (click.tick() != Bukkit.getCurrentTick()) {
+            finishedClicks.remove(player.getUniqueId());
+            return false;
+        }
+        return hand == EquipmentSlot.OFF_HAND && click.lecternKey().equals(ResearchStation.locationKey(block.getLocation()));
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        finishedClicks.remove(event.getPlayer().getUniqueId());
+    }
+
     /**
      * Resolves the station a research menu was opened for. Each menu carries its lectern location,
      * so a player with several stations only ever acts on the one whose menu is open.
diff --git a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
index 3d3c407..d62a77b 100644
--- a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
+++ b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
@@ -37,6 +37,7 @@
 import org.bukkit.event.inventory.InventoryDragEvent;
 import org.bukkit.event.inventory.InventoryType;
 import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.inventory.EquipmentSlot;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryView;
@@ -1455,6 +1456,91 @@ void aRefusedStartIsLoggedOncePerInputAndOutputUntilTheNextLoad() {
         assertEquals(1, held.getAmount());
     }
 
+    /** Seeds a complete project whose reward builds, so a main-hand reopen finishes it. */
+    private ItemStack finishableProjectWithStartItemInOffHand() {
+        output(Map.of("fire", 2));
+        project.setAspectState("fire", AspectState.CONFIRMED);
+        project.addAspectPoints("fire", 2, 2);
+        ItemStack reward = stack(Material.DIAMOND, 1);
+        items.when(() -> ItemRef.build("vanilla.DIAMOND")).thenReturn(reward);
+        rewards.when(() -> ResultSpawnEffects.spawnAtStation(location, reward)).thenReturn(true);
+        ItemStack paper = stack(Material.PAPER, 2);
+        when(bottom.getItemInOffHand()).thenReturn(paper);
+        inputs.when(() -> InputMatcher.findByStartItem(paper)).thenReturn(input("vanilla.PAPER", 1, "output"));
+        items.when(() -> ItemRef.matches(paper, "vanilla.PAPER")).thenReturn(true);
+        return paper;
+    }
+
+    @Test
+    void offHandHalfOfTheFinishingClickDoesNotStartANewProject() {
+        ItemStack paper = finishableProjectWithStartItemInOffHand();
+
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+        PlayerInteractEvent offHand = interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.OFF_HAND);
+        manager.onStationInteract(offHand);
+
+        assertTrue(project.isCompleted());
+        assertNull(manager.getStationAt(location));
+        assertTrue(offHand.isCancelled());
+        assertEquals(2, paper.getAmount());
+        inputs.verify(() -> InputMatcher.findByStartItem(any()), never());
+        verify(player, never()).sendMessage("station.started");
+        store.verify(() -> StationStore.saveStation(any()), never());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"later-tick", "other-lectern", "after-quit", "after-unload"})
+    void offHandStartsStillWorkOnOtherTicksAndLecterns(String situation) {
+        ItemStack paper = finishableProjectWithStartItemInOffHand();
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+        assertNull(manager.getStationAt(location));
+        Block target = lectern;
+        Location targetLocation = location;
+        switch (situation) {
+            case "later-tick" -> bukkit.when(Bukkit::getCurrentTick).thenReturn(1);
+            case "other-lectern" -> {
+                targetLocation = new Location(world, 30, 64, 20);
+                target = mock(Block.class);
+                when(target.getType()).thenReturn(Material.LECTERN);
+                when(target.getLocation()).thenReturn(targetLocation);
+            }
+            case "after-quit" -> manager.onPlayerQuit(new PlayerQuitEvent(player, (String) null));
+            default -> {
+                store.when(StationStore::loadAll).thenReturn(List.of());
+                manager.unloadAll();
+                manager.start();
+            }
+        }
+
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, target, EquipmentSlot.OFF_HAND));
+
+        ResearchStation started = manager.getStationAt(targetLocation);
+        assertNotNull(started);
+        assertEquals("input", started.getProject().getInputId());
+        assertEquals(1, paper.getAmount());
+        verify(player).sendMessage("station.started");
+    }
+
+    @Test
+    void withoutAFinishTheOffHandHalfOfAClickStillStartsResearch() {
+        noStations();
+        ItemStack paper = stack(Material.PAPER, 2);
+        ItemStack dirt = stack(Material.DIRT, 1);
+        when(bottom.getItemInMainHand()).thenReturn(dirt);
+        when(bottom.getItemInOffHand()).thenReturn(paper);
+        inputs.when(() -> InputMatcher.findByStartItem(paper)).thenReturn(input("vanilla.PAPER", 1, "output"));
+        items.when(() -> ItemRef.matches(paper, "vanilla.PAPER")).thenReturn(true);
+        output(Map.of("fire", 2));
+
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+        verify(player).sendMessage("station.invalid_start_item");
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.OFF_HAND));
+
+        assertNotNull(manager.getStationAt(location));
+        assertEquals(1, paper.getAmount());
+        verify(player).sendMessage("station.started");
+    }
+
     private ItemStack prepareExperiment(String primary, String secondary, Map<String, Integer> recipe) {
         output(recipe);
         ItemStack item = stack(Material.COAL, 1);

From 6554591edee93b8027e18a7d27cbd82ab7496b16 Mon Sep 17 00:00:00 2001
From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 22:28:31 +0100
Subject: [PATCH 5/6] fix: treat the next tick as the same click for the
 off-hand guard

The main-hand and off-hand packets of one click can straddle a tick
boundary, so the off-hand half is ignored in the finishing tick and the
next one; the entry expires beyond that. Tests cover the +1 tick case,
a +2 tick start, and a main-hand click in the same tick that still starts
normally. The field comment now says how entries expire.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../research/manager/ResearchManager.java       |  8 ++++++--
 .../research/manager/ResearchManagerTest.java   | 17 ++++++++++++-----
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
index e3c531b..8128849 100644
--- a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
+++ b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
@@ -72,7 +72,10 @@ public final class ResearchManager implements Listener {
             "#c45749This research is not working right now. Please tell a staff member.";
 
     private final List<ResearchStation> stations = new ArrayList<>();
-    /** At most one entry per online player: the lectern and tick of their last main-hand reopen finish. */
+    /**
+     * At most one entry per online player: the lectern and tick of their last main-hand reopen finish.
+     * Expires after its tick window; removed on the next station click, quit or unload.
+     */
     private final Map<UUID, FinishedClick> finishedClicks = new HashMap<>();
 
     private record FinishedClick(String lecternKey, int tick) {}
@@ -805,7 +808,8 @@ private boolean isOffHandOfFinishingClick(Player player, EquipmentSlot hand, Blo
         if (click == null) {
             return false;
         }
-        if (click.tick() != Bukkit.getCurrentTick()) {
+        // The two hand packets of one click can straddle a tick boundary, so the window is this tick and the next.
+        if (Bukkit.getCurrentTick() - click.tick() > 1) {
             finishedClicks.remove(player.getUniqueId());
             return false;
         }
diff --git a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
index d62a77b..332f3f3 100644
--- a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
+++ b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
@@ -1471,11 +1471,13 @@ private ItemStack finishableProjectWithStartItemInOffHand() {
         return paper;
     }
 
-    @Test
-    void offHandHalfOfTheFinishingClickDoesNotStartANewProject() {
+    @ParameterizedTest
+    @ValueSource(ints = {0, 1})
+    void offHandHalfOfTheFinishingClickDoesNotStartANewProject(int ticksLater) {
         ItemStack paper = finishableProjectWithStartItemInOffHand();
 
         manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
+        bukkit.when(Bukkit::getCurrentTick).thenReturn(ticksLater);
         PlayerInteractEvent offHand = interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.OFF_HAND);
         manager.onStationInteract(offHand);
 
@@ -1489,15 +1491,20 @@ void offHandHalfOfTheFinishingClickDoesNotStartANewProject() {
     }
 
     @ParameterizedTest
-    @ValueSource(strings = {"later-tick", "other-lectern", "after-quit", "after-unload"})
+    @ValueSource(strings = {"later-tick", "other-lectern", "after-quit", "after-unload", "main-hand-same-tick"})
     void offHandStartsStillWorkOnOtherTicksAndLecterns(String situation) {
         ItemStack paper = finishableProjectWithStartItemInOffHand();
         manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
         assertNull(manager.getStationAt(location));
         Block target = lectern;
         Location targetLocation = location;
+        EquipmentSlot hand = EquipmentSlot.OFF_HAND;
         switch (situation) {
-            case "later-tick" -> bukkit.when(Bukkit::getCurrentTick).thenReturn(1);
+            case "later-tick" -> bukkit.when(Bukkit::getCurrentTick).thenReturn(2);
+            case "main-hand-same-tick" -> {
+                when(bottom.getItemInMainHand()).thenReturn(paper);
+                hand = EquipmentSlot.HAND;
+            }
             case "other-lectern" -> {
                 targetLocation = new Location(world, 30, 64, 20);
                 target = mock(Block.class);
@@ -1512,7 +1519,7 @@ void offHandStartsStillWorkOnOtherTicksAndLecterns(String situation) {
             }
         }
 
-        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, target, EquipmentSlot.OFF_HAND));
+        manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, target, hand));
 
         ResearchStation started = manager.getStationAt(targetLocation);
         assertNotNull(started);

From 0a902ab6eb813c294b91a6027dc3886cfcc96272 Mon Sep 17 00:00:00 2001
From: XxFran10xX <318299142+XxFran10xX@users.noreply.github.com>
Date: Fri, 13 Nov 2026 22:33:31 +0100
Subject: [PATCH 6/6] docs: reword the finished-click comment and rename the
 start test

Wording only: the field comment says when entries are removed, and the
parameterized start test is now startsStillWorkOutsideTheFinishingClick.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../java/net/tfminecraft/research/manager/ResearchManager.java  | 2 +-
 .../net/tfminecraft/research/manager/ResearchManagerTest.java   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
index 8128849..f0ad055 100644
--- a/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
+++ b/src/main/java/net/tfminecraft/research/manager/ResearchManager.java
@@ -74,7 +74,7 @@ public final class ResearchManager implements Listener {
     private final List<ResearchStation> stations = new ArrayList<>();
     /**
      * At most one entry per online player: the lectern and tick of their last main-hand reopen finish.
-     * Expires after its tick window; removed on the next station click, quit or unload.
+     * An expired entry is removed on that player's next station click; all entries go on quit or unload.
      */
     private final Map<UUID, FinishedClick> finishedClicks = new HashMap<>();
 
diff --git a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
index 332f3f3..4010fe0 100644
--- a/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
+++ b/src/test/java/net/tfminecraft/research/manager/ResearchManagerTest.java
@@ -1492,7 +1492,7 @@ void offHandHalfOfTheFinishingClickDoesNotStartANewProject(int ticksLater) {
 
     @ParameterizedTest
     @ValueSource(strings = {"later-tick", "other-lectern", "after-quit", "after-unload", "main-hand-same-tick"})
-    void offHandStartsStillWorkOnOtherTicksAndLecterns(String situation) {
+    void startsStillWorkOutsideTheFinishingClick(String situation) {
         ItemStack paper = finishableProjectWithStartItemInOffHand();
         manager.onStationInteract(interact(Action.RIGHT_CLICK_BLOCK, lectern, EquipmentSlot.HAND));
         assertNull(manager.getStationAt(location));