fix(resolver): four robustness fixes from dual-agent (superpowers + codex) brainstorm

Both reviewers independently identified the same four corner-cases in the
Phase 4 + 6 wiring; this lands the converged fix list.

1. JavaSymbolResolver — `volatile` on `solver` and `combined`
   bootstrap() publishes; resolve() and the public accessors read from
   arbitrary virtual-thread carriers. The JLS Thread Start Rule covers
   the executor.submit() path but does NOT cover callers that read the
   public accessors after bootstrap on a different thread. Cheap fence,
   closes the visibility hole.

2. JavaSymbolResolver.resolve(String) — strict parse-success check
   JavaParser is permissive and may return a partial CompilationUnit
   even when the source has parse problems. Resolving against a partial
   CU silently emits simple-name-only edges and looks like coverage
   even though resolution is broken. Treat any non-success as
   EmptyResolved so the graph never carries phantom RESOLVED-tier
   edges from broken parses.

3. Analyzer.resolveFor — catch StackOverflowError
   Pathological generic / type-cycle inputs can blow JavaSymbolSolver's
   recursion stack. Catching the Error keeps the virtual-thread worker
   alive and degrades that file's resolution to lexical. Other Errors
   (OOM, ThreadDeath) remain fatal and propagate.

4. JavaSourceRootDiscovery.containsJavaFile — try-with-resources on Files.walk
   Files.walk holds an open directory stream; without a close, the file
   descriptor leaks for every plain-layout fallback scan. Cheap fix.

mvn test: 3592 tests / 0 failures / 31 skipped (full suite, no regressions).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: aksOps

src/main/java/io/github/randomcodespace/iq/analyzer/Analyzer.java

@@ -220,6 +220,15 @@ private Resolved resolveFor(DiscoveredFile file, Object parsedAst, String conten
             log.debug("resolver {} threw unexpectedly for {}: {}",
                     resolver.getClass().getSimpleName(), file.path(), e.toString());
             return EmptyResolved.INSTANCE;
+        } catch (StackOverflowError e) {
+            // Pathological generic / type-cycle inputs can blow JavaSymbolSolver's
+            // recursion stack. Catching the Error keeps the virtual-thread
+            // worker alive and the file's resolution simply degrades to lexical.
+            // Other Errors (OOM, ThreadDeath) are not caught — they're fatal and
+            // should propagate.
+            log.warn("resolver {} stack-overflowed for {} — falling back to lexical",
+                    resolver.getClass().getSimpleName(), file.path());
+            return EmptyResolved.INSTANCE;
         }
     }
 

src/main/java/io/github/randomcodespace/iq/intelligence/resolver/java/JavaSourceRootDiscovery.java

@@ -123,8 +123,11 @@ private static String nameOrEmpty(Path p) {
 
     /** Cheap probe: does the directory tree under {@code root} have any {@code *.java}? */
     private static boolean containsJavaFile(Path root) {
-        try {
-            return Files.walk(root)
+        // try-with-resources: Files.walk holds an open directory stream; without
+        // a close, the file descriptor leaks for every plain-layout fallback
+        // scan. Cheap fix.
+        try (java.util.stream.Stream<Path> stream = Files.walk(root)) {
+            return stream
                     .filter(p -> !Files.isDirectory(p))
                     .anyMatch(p -> p.toString().endsWith(".java"));
         } catch (IOException e) {

src/main/java/io/github/randomcodespace/iq/intelligence/resolver/java/JavaSymbolResolver.java

@@ -40,8 +40,15 @@
 public class JavaSymbolResolver implements SymbolResolver {
 
     private final JavaSourceRootDiscovery discovery;
-    private CombinedTypeSolver combined;
-    private JavaSymbolSolver solver;
+    // volatile: bootstrap() publishes the solver; resolve() and the public
+    // accessors read it from arbitrary virtual-thread carriers. Without
+    // volatile a reader could see a half-initialized JavaSymbolSolver — a
+    // narrow race that the JLS Thread Start Rule covers for the
+    // executor.submit() path but does NOT cover for callers that read the
+    // public accessors after bootstrap on a different thread. The fence is
+    // cheap; the alternative is a quiet correctness hole.
+    private volatile CombinedTypeSolver combined;
+    private volatile JavaSymbolSolver solver;
 
     public JavaSymbolResolver(JavaSourceRootDiscovery discovery) {
         this.discovery = discovery;
@@ -96,11 +103,14 @@ public Resolved resolve(DiscoveredFile file, Object parsedAst) {
             // symbol solver so resolve()s on the resulting AST work.
             ParserConfiguration cfg = new ParserConfiguration().setSymbolResolver(solver);
             ParseResult<CompilationUnit> parseResult = new JavaParser(cfg).parse(source);
-            if (parseResult.getResult().isEmpty()) {
-                // Unparseable source — return EmptyResolved rather than
-                // surface a parse exception. Detectors that need the raw
-                // content already have ctx.content() — symbol resolution
-                // simply isn't available for files JavaParser can't accept.
+            // Strict success check: JavaParser is permissive and may hand
+            // back a partial CompilationUnit even when the source has parse
+            // problems. Resolving against a partial CU silently emits
+            // simple-name-only edges and looks like coverage even though
+            // symbol resolution is broken. Treat any non-success as
+            // "EmptyResolved, fall back to lexical" so the downstream graph
+            // never carries phantom RESOLVED-tier edges from broken parses.
+            if (!parseResult.isSuccessful() || parseResult.getResult().isEmpty()) {
                 return EmptyResolved.INSTANCE;
             }
             cu = parseResult.getResult().get();