fix(hostplugin): correct lifespan + loader semantics so the host bean wires

Three corrections surfaced by the full 335-test gate (Task 14 of the LTA
2026.1 migration plan); none was caught by the spec's javap analysis:

1. PluginRuntime.loadFrom — second arg to PluginsLoader.load is
   disabledPluginsForAnalysis, not additionalAllowedPlugins as the spec
   assumed. Passing "sonarpredict-host" actively EXCLUDED our host plugin
   from every Spring analysis container, leaving AnalysisWarnings unwired
   and reproducing the original "wall". Reverted to Set.of().

2. NoOpAnalysisWarnings @SonarLintSide(lifespan = INSTANCE -> SINGLE_ANALYSIS).
   The per-analysis AnalysisContainer calls install(ContainerLifespan.ANALYSIS),
   which matches the SINGLE_ANALYSIS string constant — not INSTANCE.
   HtmlSensor, the sensor that triggered the original NoSuchBeanDefinitionException,
   lives in this same container.

3. host-plugin-jar maven execution moved from prepare-package to
   process-test-classes, plus a maven-antrun copy-host-plugin-for-tests
   step that seeds the dev plugins/ dir with the host JAR. Required so the
   surefire-time daemon tests (which use AnalysisService's no-arg ctor =
   plugins/) can find the host plugin without a full assembly run.

HostPluginIntegrationTest refactored to use @tempdir + hardlink-or-copy
the vendored analyzer JARs plus the host JAR, filtering out *-host.jar
from the vendored glob to avoid a duplicate FileAlreadyExistsException
when antrun has already populated plugins/.

After these three corrections, full mvn verify reports 335/335 tests
passing, JaCoCo report intact, and the unpacked dist bundle analyzes a
Java fixture cleanly with zero NoSuchBeanDefinitionException occurrences.

Author: aksOps

pom.xml

@@ -211,7 +211,7 @@
                     </execution>
                     <execution>
                         <id>host-plugin-jar</id>
-                        <phase>prepare-package</phase>
+                        <phase>process-test-classes</phase>
                         <goals><goal>jar</goal></goals>
                         <configuration>
                             <classifier>host</classifier>
@@ -400,6 +400,42 @@
                 </executions>
             </plugin>
 
+            <!--
+              Copy the host plugin jar into the dev plugins/ directory so
+              that AnalysisService (no-arg constructor → plugins/) and
+              PluginRuntime.loadAll pick it up during mvn test.
+
+              The host-plugin-jar jar-plugin execution (process-test-classes)
+              produces target/sonar-predictor-${project.version}-host.jar.
+              This antrun execution binds to the SAME phase so it runs
+              immediately after the jar is written.
+
+              The file is gitignored (plugins/*.jar). In production the host
+              jar ships inside the dist zip's plugins/ directory via the
+              assembly descriptor, so no separate production step is needed.
+            -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-antrun-plugin</artifactId>
+                <version>3.1.0</version>
+                <executions>
+                    <execution>
+                        <id>copy-host-plugin-for-tests</id>
+                        <phase>process-test-classes</phase>
+                        <goals><goal>run</goal></goals>
+                        <configuration>
+                            <target>
+                                <copy todir="${project.basedir}/plugins" overwrite="true">
+                                    <fileset dir="${project.build.directory}">
+                                        <include name="${project.artifactId}-${project.version}-host.jar"/>
+                                    </fileset>
+                                </copy>
+                            </target>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+
             <!-- Assemble the dist bundle: bin/ launchers + lib/ fat jars +
                  plugins/ analyzer jars, zipped. Output:
                  target/sonar-predictor-dist-${project.version}.zip. -->

src/main/java/io/github/randomcodespace/sonarpredict/daemon/PluginRuntime.java

@@ -105,7 +105,13 @@ public static LoadedPlugins loadFrom(Set<Path> jars) {
                 V1_LANGUAGES,
                 false,
                 detectNodeVersion());
-        PluginsLoadResult result = new PluginsLoader().load(config, Set.of("sonarpredict-host"));
+        // Second argument is disabledPluginsForAnalysis — keys in this set are excluded
+        // from getAnalysisPluginInstancesByKeys() and therefore never installed into any
+        // Spring analysis container. Pass an empty set so the host plugin's extensions
+        // (NoOpAnalysisWarnings) are visible to sensors such as HtmlSensor that autowire
+        // AnalysisWarnings. The engine's own "additionalAllowedPlugins" list (textdeveloper,
+        // textenterprise, etc.) is built internally by PluginsLoader and is separate.
+        PluginsLoadResult result = new PluginsLoader().load(config, Set.of());
         return result.getLoadedPlugins();
     }
 

src/main/java/io/github/randomcodespace/sonarpredict/hostplugin/NoOpAnalysisWarnings.java

@@ -12,10 +12,13 @@
  * Spring-autowire. Engine 11.3 ships zero references to {@code AnalysisWarnings}, so the
  * host plugin provides this bean.
  *
- * <p>Lifespan is {@code INSTANCE} (per-analysis) — the engine instantiates a fresh
- * instance per analysis, which resets the dedupe set automatically.
+ * <p>Lifespan is {@code SINGLE_ANALYSIS} — maps to {@code ContainerLifespan.ANALYSIS}
+ * in the engine. The per-analysis {@code AnalysisContainer} calls
+ * {@code install(ContainerLifespan.ANALYSIS)}, so this bean is registered into the
+ * same Spring container that wires sensors such as {@code HtmlSensor} which declare
+ * {@code AnalysisWarnings} as a constructor parameter.
  */
-@SonarLintSide(lifespan = SonarLintSide.INSTANCE)
+@SonarLintSide(lifespan = SonarLintSide.SINGLE_ANALYSIS)
 public final class NoOpAnalysisWarnings implements AnalysisWarnings {
 
     private static final Logger LOG = LoggerFactory.getLogger(NoOpAnalysisWarnings.class);

src/test/java/io/github/randomcodespace/sonarpredict/hostplugin/HostPluginIntegrationTest.java

@@ -12,11 +12,15 @@
 import java.util.stream.Stream;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
 import org.slf4j.LoggerFactory;
 import org.sonarsource.sonarlint.core.plugin.commons.LoadedPlugins;
 
 class HostPluginIntegrationTest {
 
+    @TempDir
+    Path tempPluginsDir;
+
     private ListAppender<ILoggingEvent> appender;
 
     @BeforeEach
@@ -28,29 +32,62 @@ void setUp() {
 
     @Test
     void loadAll_includesHostPluginAndNoMissingBeanErrors() throws IOException {
-        Path pluginsDir = findDistPluginsDir();
+        populateTempPluginsDir(tempPluginsDir);
 
-        LoadedPlugins loaded = PluginRuntime.loadAll(pluginsDir);
+        LoadedPlugins loaded = PluginRuntime.loadAll(tempPluginsDir);
 
         assertThat(loaded.getAllPluginInstancesByKeys()).containsKey("sonarpredict-host");
         assertThat(appender.list).noneMatch(e ->
                 e.getFormattedMessage() != null
                 && e.getFormattedMessage().contains("NoSuchBeanDefinitionException"));
     }
 
-    private static Path findDistPluginsDir() throws IOException {
+    /**
+     * Assembles a temporary plugins directory by hard-linking all JARs from the
+     * vendored {@code plugins/} directory (populated at process-test-resources)
+     * and the host plugin JAR produced at process-test-classes.
+     *
+     * <p>Hard-links are used where supported (same filesystem); Files.copy falls
+     * back transparently when the link target is on a different device.
+     */
+    private static void populateTempPluginsDir(Path tempDir) throws IOException {
+        // Vendor analyzer JARs — present at process-test-resources phase.
+        // Exclude the host JAR (sonar-predictor-*-host.jar) from this glob:
+        // antrun copies it into plugins/ at process-test-classes, but findHostJar()
+        // below adds it explicitly to avoid a duplicate / FileAlreadyExistsException.
+        Path vendorPluginsDir = Path.of("plugins");
+        try (Stream<Path> entries = Files.list(vendorPluginsDir)) {
+            for (Path jar : (Iterable<Path>) entries
+                    .filter(p -> p.getFileName().toString().endsWith(".jar"))
+                    .filter(p -> !p.getFileName().toString().contains("-host.jar"))::iterator) {
+                linkOrCopy(jar, tempDir.resolve(jar.getFileName()));
+            }
+        }
+
+        // Host plugin JAR — produced at process-test-classes phase
+        Path hostJar = findHostJar();
+        linkOrCopy(hostJar, tempDir.resolve(hostJar.getFileName()));
+    }
+
+    private static void linkOrCopy(Path source, Path target) throws IOException {
+        try {
+            Files.createLink(target, source.toAbsolutePath());
+        } catch (UnsupportedOperationException | IOException e) {
+            Files.copy(source.toAbsolutePath(), target);
+        }
+    }
+
+    private static Path findHostJar() throws IOException {
         Path targetDir = Path.of("target");
-        try (Stream<Path> dirs = Files.list(targetDir)) {
-            Path distRoot = dirs
-                    .filter(Files::isDirectory)
+        try (Stream<Path> entries = Files.list(targetDir)) {
+            return entries
                     .filter(p -> {
                         String n = p.getFileName().toString();
-                        return n.startsWith("sonar-predictor-dist-");
+                        return n.startsWith("sonar-predictor-") && n.endsWith("-host.jar");
                     })
                     .findFirst()
                     .orElseThrow(() -> new IllegalStateException(
-                            "dist exploded dir not found in target/; run `mvn package -DskipTests` first"));
-            return distRoot.resolve("sonar-predictor").resolve("plugins");
+                            "host jar not found in target/; run `mvn package -DskipTests` first"));
         }
     }
 }