feat: wire Phase 2 symbol-reference indexing and fix createListener crash

- Fix MockComponentManager.createListener crash by adding reflective
  fallback in LazyListenerKt that instantiates listeners directly when
  the message bus owner doesn't support createListener

- Wire Phase 2 background indexing: scanFileReferences() walks PSI
  trees, resolves references via K2, and populates symbol_references
  table after Phase 1 completes

- Refactor BackgroundIndexer.startPhase2 to use scan-then-batch-write
  pattern (chunked by 50) to minimize SQLite write contention

- Cancel backgroundIndexer before cache invalidation in
  refreshWorkspace() to prevent Phase 2 from recreating deleted files

- Add 14 new tests:
  - 5 SQLite CRUD tests for symbol_references operations
  - 5 BackgroundIndexer Phase 2 lifecycle tests
  - 3 findReferences cache-hit/fallback integration tests
  - 1 LazyListenerKt reflective fallback test

Co-authored-by: Copilot <[email protected]>

Author: amichne

backend-standalone/src/compat/java/com/intellij/util/messages/impl/LazyListenerKt.java

@@ -68,7 +68,16 @@ public static void subscribeLazyListeners(
                     throw exception;
                 }
                 catch (Throwable exception) {
-                    MessageBusImpl.LOG.error("Cannot create listener", exception);
+                    // Standalone mode: MockComponentManager throws UnsupportedOperationException
+                    // from createListener. Fall back to direct reflective instantiation so that
+                    // K2 FIR session invalidation listeners (and any other lazy listeners) are
+                    // still registered.
+                    Object fallback = instantiateListenerDirectly(descriptor);
+                    if (fallback != null) {
+                        handlers.add(fallback);
+                    } else {
+                        MessageBusImpl.LOG.error("Cannot create listener", exception);
+                    }
                 }
             }
 
@@ -213,4 +222,30 @@ else if (filteredHandlers != null) {
         }
         return filteredHandlers;
     }
+
+    /**
+     * Reflective fallback for standalone mode where {@code MockComponentManager.createListener}
+     * throws {@link UnsupportedOperationException}. Loads the listener class using the plugin
+     * descriptor's classloader and instantiates it via the no-arg constructor.
+     *
+     * @return the instantiated listener, or {@code null} if instantiation fails
+     */
+    private static Object instantiateListenerDirectly(PluginListenerDescriptor descriptor) {
+        try {
+            String listenerClassName = descriptor.getDescriptor().listenerClassName;
+            ClassLoader classLoader = descriptor.getPluginDescriptor().getPluginClassLoader();
+            if (classLoader == null) {
+                classLoader = Thread.currentThread().getContextClassLoader();
+            }
+            if (classLoader == null) {
+                classLoader = LazyListenerKt.class.getClassLoader();
+            }
+            Class<?> listenerClass = Class.forName(listenerClassName, true, classLoader);
+            java.lang.reflect.Constructor<?> constructor = listenerClass.getDeclaredConstructor();
+            constructor.setAccessible(true);
+            return constructor.newInstance();
+        } catch (Throwable fallbackException) {
+            return null;
+        }
+    }
 }

backend-standalone/src/main/kotlin/io/github/amichne/kast/standalone/BackgroundIndexer.kt

@@ -92,20 +92,37 @@ internal class BackgroundIndexer(
                 if (cancelled) return@thread
                 val allPaths = store.loadManifest()?.keys ?: return@thread
                 generation.incrementAndGet()
-                for (filePath in allPaths) {
+                val pathList = allPaths.toList()
+                // Process files in batches: scan without holding a transaction, then
+                // batch-write results in a short transaction to minimize SQLite contention.
+                for (batch in pathList.chunked(PHASE2_BATCH_SIZE)) {
                     if (cancelled || Thread.currentThread().isInterrupted) break
-                    runCatching {
-                        store.clearReferencesFromFile(filePath)
-                        val refs = referenceScanner(filePath)
-                        refs.forEach { ref ->
-                            store.upsertSymbolReference(
-                                sourcePath = ref.sourcePath,
-                                sourceOffset = ref.sourceOffset,
-                                targetFqName = ref.targetFqName,
-                                targetPath = ref.targetPath,
-                                targetOffset = ref.targetOffset,
-                            )
+                    // Phase A: scan files (no SQLite writes, may be slow due to K2 resolution)
+                    val batchResults = batch.mapNotNull { filePath ->
+                        if (cancelled || Thread.currentThread().isInterrupted) return@mapNotNull null
+                        runCatching {
+                            filePath to referenceScanner(filePath)
+                        }.getOrNull()
+                    }
+                    if (cancelled || Thread.currentThread().isInterrupted) break
+                    // Phase B: batch-write in a short transaction
+                    store.beginTransaction()
+                    try {
+                        for ((filePath, refs) in batchResults) {
+                            store.clearReferencesFromFile(filePath)
+                            refs.forEach { ref ->
+                                store.upsertSymbolReference(
+                                    sourcePath = ref.sourcePath,
+                                    sourceOffset = ref.sourceOffset,
+                                    targetFqName = ref.targetFqName,
+                                    targetPath = ref.targetPath,
+                                    targetOffset = ref.targetOffset,
+                                )
+                            }
                         }
+                        store.commitTransaction()
+                    } catch (e: Exception) {
+                        store.rollbackTransaction()
                     }
                 }
                 if (!cancelled) {
@@ -168,6 +185,11 @@ internal class BackgroundIndexer(
     // Phase 1 internals
     // -------------------------------------------------------------------------
 
+    companion object {
+        /** Number of files to batch per Phase 2 transaction to reduce SQLite write contention. */
+        private const val PHASE2_BATCH_SIZE = 50
+    }
+
     private fun loadOrBuildIndex(): MutableSourceIdentifierIndex {
         val incrementalResult = runCatching {
             sourceIndexCache.load(sourceRoots)

backend-standalone/src/main/kotlin/io/github/amichne/kast/standalone/StandaloneAnalysisSession.kt

@@ -12,6 +12,7 @@ import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.platform.syntax.psi.CommonElementTypeConverterFactory
 import com.intellij.platform.syntax.psi.ElementTypeConverters
 import com.intellij.psi.PsiManager
+import com.intellij.psi.PsiRecursiveElementWalkingVisitor
 import com.intellij.psi.compiled.ClassFileDecompilers
 import com.intellij.psi.impl.PsiManagerEx
 import io.github.amichne.kast.api.FqName
@@ -21,9 +22,12 @@ import io.github.amichne.kast.api.NormalizedPath
 import io.github.amichne.kast.api.NotFoundException
 import io.github.amichne.kast.api.PackageName
 import io.github.amichne.kast.api.RefreshResult
+import io.github.amichne.kast.standalone.analysis.resolvedFilePath
+import io.github.amichne.kast.standalone.analysis.targetFqNameAndPackage
 import io.github.amichne.kast.standalone.cache.CacheManager
 import io.github.amichne.kast.standalone.cache.SourceIndexCache
 import io.github.amichne.kast.standalone.cache.SqliteSourceIndexStore
+import io.github.amichne.kast.standalone.cache.SymbolReferenceRow
 import io.github.amichne.kast.standalone.cache.scanTrackedKotlinFileTimestamps
 import io.github.amichne.kast.standalone.workspace.PhasedDiscoveryResult
 import org.jetbrains.kotlin.analysis.api.projectStructure.KaSourceModule
@@ -205,7 +209,6 @@ internal class StandaloneAnalysisSession(
                         fileManager.setViewProvider(virtualFile, null)
                     }
                 }
-                PsiManager.getInstance(session.project).dropResolveCaches()
             }
 
             normalizedPaths.forEach { normalizedPath ->
@@ -236,6 +239,7 @@ internal class StandaloneAnalysisSession(
             }
         }
 
+        PsiManager.getInstance(session.project).dropResolveCaches()
         refreshSourceIdentifierIndex(normalizedPaths)
         targetedCandidatePathsByLookupKey.clear()
         return buildRefreshResult(normalizedPaths, fullRefresh = false)
@@ -275,8 +279,32 @@ internal class StandaloneAnalysisSession(
         return buildRefreshResult(normalizedPaths, fullRefresh = false)
     }
 
+    /**
+     * Rebuilds the K2 analysis session without a full workspace refresh.
+     *
+     * In K2 standalone mode, `KotlinStandaloneDeclarationProviderFactory` builds a
+     * static declaration index at session construction time. Content changes that alter
+     * declaration signatures (e.g., renames) require a session rebuild for cross-file
+     * resolution to pick up the new names. The lightweight `refreshFileContents` path
+     * updates PSI/VFS and our source identifier index, but cannot incrementally update
+     * K2's declaration index because standalone mode's `MockComponentManager` does not
+     * support the message-bus-based invalidation that IDE mode relies on.
+     *
+     * Call this after `refreshFileContents` when the edits include declaration-level
+     * changes and cross-file resolution correctness is required.
+     */
+    fun rebuildAnalysisSession() {
+        analysisSessionLock.write {
+            val previousDisposable = sessionStateDisposable
+            buildAnalysisStateAndCache()
+            fullKtFileMapLoaded = false
+            Disposer.dispose(previousDisposable)
+        }
+    }
+
     fun refreshWorkspace(invalidateCaches: Boolean = false): RefreshResult {
         if (invalidateCaches) {
+            backgroundIndexer.close()
             cacheManager.invalidateAll()
         }
         val currentPaths = allTrackedKotlinSourcePaths()
@@ -686,7 +714,51 @@ internal class StandaloneAnalysisSession(
                 applyPendingSourceIndexRefreshes(builtIndex)
                 sourceIdentifierIndex.set(builtIndex)
             }
+            backgroundIndexer.startPhase2(::scanFileReferences)
+        }
+    }
+
+    /**
+     * Phase 2 reference scanner: walks a single file's PSI tree, resolves references
+     * via the K2 analysis session, and extracts [SymbolReferenceRow]s mapping each
+     * reference site to its target's fully-qualified name, path, and offset.
+     *
+     * Called per-file on the Phase 2 background thread. Errors for individual elements
+     * are silently skipped so one bad reference doesn't abort the entire file scan.
+     */
+    private fun scanFileReferences(filePath: String): List<SymbolReferenceRow> {
+        val rows = mutableListOf<SymbolReferenceRow>()
+        withReadAccess {
+            val ktFile = runCatching { findKtFile(filePath) }.getOrNull() ?: return@withReadAccess
+            val sourceFilePath = runCatching { ktFile.resolvedFilePath().value }.getOrElse { filePath }
+
+            ktFile.accept(
+                object : PsiRecursiveElementWalkingVisitor() {
+                    override fun visitElement(element: com.intellij.psi.PsiElement) {
+                        element.references.forEach { reference ->
+                            runCatching {
+                                val resolved = reference.resolve() ?: return@forEach
+                                val fqNameAndPkg = resolved.targetFqNameAndPackage() ?: return@forEach
+                                val (fqName, _) = fqNameAndPkg
+                                val targetPath = runCatching { resolved.resolvedFilePath().value }.getOrNull()
+                                val targetOffset = resolved.textRange?.startOffset
+                                val sourceOffset = reference.element.textRange.startOffset +
+                                    reference.rangeInElement.startOffset
+                                rows += SymbolReferenceRow(
+                                    sourcePath = sourceFilePath,
+                                    sourceOffset = sourceOffset,
+                                    targetFqName = fqName.value,
+                                    targetPath = targetPath,
+                                    targetOffset = targetOffset,
+                                )
+                            }
+                        }
+                        super.visitElement(element)
+                    }
+                },
+            )
         }
+        return rows
     }
 
     private fun applyPendingSourceIndexRefreshes(index: MutableSourceIdentifierIndex) {