refactor: diff preview to use server snapshot and remove stale cache test

Author: AshotN

.opencode/skills/writing-test-with-trace/SKILL.md

@@ -12,11 +12,29 @@ captures the issue. The test must fail before any fix is applied.
 
 # Trace files
 
-Trace files are located in `/tmp/opencode-diff-traces`. List the directory first to find the most
-recent file (sorted by modification time). Check its line count with `wc -l` before reading. If it
-is small (under a few hundred lines), read it in full with `cat`. If it is large, use `grep` to
-filter by the `kind` values relevant to the issue, or read the tail with `tail -n N` to focus on
-the most recent events.
+Use a explore sub-agent to find the most recent trace
+
+Trace files are written under Java's temp directory, not necessarily literal `/tmp`. The code uses
+`Path.of(System.getProperty("java.io.tmpdir"), "opencode-diff-traces")`.
+
+On macOS this often resolves to a sandboxed path such as
+`/var/folders/.../T/opencode-diff-traces`, even though users may describe it as `/tmp`. Do not
+assume `/tmp/opencode-diff-traces` exists before checking how `java.io.tmpdir` was resolved for the
+running IDE instance.
+
+If the user ran the plugin from Gradle's `Run Plugin` configuration, check the sandbox IDE log
+first to find the exact trace file path. In this repo that is typically
+`build/idea-sandbox/IU-*/log/idea.log`. Search for:
+
+- `JsonlDiffTracer: tracing enabled file=`
+- `failed to create trace directory`
+- `failed to open trace file`
+
+Use that log line to locate the exact JSONL trace file before reading it. Once you know the
+directory, list it to find the most recent file (sorted by modification time). Check its line count
+with `wc -l` before reading. If it is small (under a few hundred lines), read it in full with
+`cat`. If it is large, use `grep` to filter by the `kind` values relevant to the issue, or read the
+tail with `tail -n N` to focus on the most recent events.
 
 Each line is a JSON object. Read events in `seq` order. Each event has a `kind`, a `sessionId`
 inside `fields`, and additional fields that vary by kind. Read the fields that are present and
@@ -40,6 +58,7 @@ is already available. Use what fits; build what doesn't exist yet.
 ## Test structure
 
 Each test must have:
+
 1. A block comment stating the **invariant** being enforced.
 2. A **MANUAL VERIFICATION** section: numbered, concrete steps the user can follow in the running
    plugin to confirm the fix. Do not start with "Run the plugin". Example:
@@ -56,12 +75,14 @@ The comment must describe the **user-visible invariant** — what the user expec
 implementation mechanism that enforces it. Code changes; the user expectation does not.
 
 **Wrong** (describes implementation):
+
 ```
 // Child session liveHunks are keyed by child session ID; the family query must include active
 // child sessions regardless of whether parentBySessionId has been populated yet.
 ```
 
 **Right** (describes user expectation):
+
 ```
 // When the AI delegates work to parallel sub-agents, every file touched by any sub-agent must
 // show a green highlight in the editor. All files must be visible simultaneously.

opencode.json

@@ -14,7 +14,7 @@
   "agent": {
     "explore": {
       "mode": "subagent",
-      "model": "anthropic/claude-haiku-4-5"
+      "model": "openai/gpt-5.4-mini"
     }
   }
 }

src/main/kotlin/com/ashotn/opencode/relay/api/session/SessionApiClient.kt

@@ -24,7 +24,7 @@ class SessionApiClient(
 
     data class FileDiffPreview(
         val before: String,
-        val after: String?,
+        val after: String,
     )
 
     fun createSession(port: Int): ApiResult<CreatedSession> {

src/main/kotlin/com/ashotn/opencode/relay/core/OpenCodeCoreService.kt

@@ -565,7 +565,6 @@ class OpenCodeCoreService(private val project: Project) : Disposable {
             stateStore.addedBySession.remove(sessionId)
             stateStore.baselineBeforeBySessionAndFile.remove(sessionId)
             stateStore.lastAfterBySessionAndFile.remove(sessionId)
-            stateStore.serverAfterBySessionAndFile.remove(sessionId)
             stateStore.pendingTurnFilesBySession.remove(sessionId)
             historicalDiffLoadedSessions.remove(sessionId)
 
@@ -656,16 +655,15 @@ class OpenCodeCoreService(private val project: Project) : Disposable {
     fun allTrackedFiles(): Set<String> = synchronized(stateLock) { visibleFilesLocked() }
 
     fun getFileDiffPreview(filePath: String, onResult: (FileDiffPreview?) -> Unit) {
-        val (sessionId, currentPort, storedServerAfter) = synchronized(stateLock) {
+        val (sessionId, currentPort) = synchronized(stateLock) {
             val candidateSessionIds = queryService.previewCandidateSessionIds(
                 familySessionIds = { familySessionIdsLocked() },
                 updatedAtBySession = stateStore.updatedAtBySession,
             )
             val sid = candidateSessionIds.firstOrNull { sessionId ->
                 stateStore.baselineBeforeBySessionAndFile[sessionId]?.containsKey(filePath) == true
             } ?: return onResult(null)
-            val serverAfter = stateStore.serverAfterBySessionAndFile[sid]?.get(filePath)
-            Triple(sid, port, serverAfter)
+            sid to port
         }
 
         if (currentPort <= 0) return onResult(null)
@@ -687,16 +685,12 @@ class OpenCodeCoreService(private val project: Project) : Disposable {
                         onResult(null)
                         return@executeOnPooledThread
                     }
-
-                    // Prefer the in-memory server-reported AI after (captured at SSE event time);
-                    // fall back to the REST snapshot's after field.
-                    val aiAfter = storedServerAfter ?: preview.after ?: documentSyncService.readCurrentContent(filePath)
                     onResult(
                         FileDiffPreview(
                             filePath = filePath,
                             sessionId = sessionId,
                             before = preview.before,
-                            aiAfter = aiAfter,
+                            aiAfter = preview.after,
                         )
                     )
                 }

src/main/kotlin/com/ashotn/opencode/relay/core/SessionDiffApplyComputer.kt

@@ -25,7 +25,6 @@ internal class SessionDiffApplyComputer(
         val newDeleted = HashSet<String>()
         val newAdded = HashSet<String>()
         val newBaselineByFile = HashMap<String, String>()
-        val newServerAfterByFile = HashMap<String, String>()
         val processedPaths = HashSet<String>()
         val nextAfterByFile = previousAfterByFile.toMutableMap()
         var outOfScopeCount = 0
@@ -50,11 +49,6 @@ internal class SessionDiffApplyComputer(
 
             processedPaths.add(absPath)
 
-            // Capture the server's intended "after AI" content for the diff viewer.
-            // Always record it — including empty string — so that a turn which
-            // intentionally empties a file clears any stale value from a prior turn.
-            newServerAfterByFile[absPath] = diffFile.after
-
             if (!fromHistory) {
                 onFileProcessing?.invoke(absPath, diffFile.status)
             }
@@ -197,7 +191,6 @@ internal class SessionDiffApplyComputer(
             newDeleted = newDeleted,
             newAdded = newAdded,
             newBaselineByFile = newBaselineByFile,
-            newServerAfterByFile = newServerAfterByFile,
         )
     }
-}
+}

src/main/kotlin/com/ashotn/opencode/relay/core/StateStore.kt

@@ -10,7 +10,6 @@ internal class StateStore {
         val newDeleted: Set<String>,
         val newAdded: Set<String>,
         val newBaselineByFile: Map<String, String>,
-        val newServerAfterByFile: Map<String, String>,
     )
 
     data class SessionDiffCommitResult(
@@ -30,9 +29,6 @@ internal class StateStore {
     val addedBySession = ConcurrentHashMap<String, Set<String>>()
     val baselineBeforeBySessionAndFile = ConcurrentHashMap<String, Map<String, String>>()
     val lastAfterBySessionAndFile = ConcurrentHashMap<String, MutableMap<String, String>>()
-
-    /** The server's intended "after AI" content per file per session, sourced from SessionDiffFile.after. */
-    val serverAfterBySessionAndFile = ConcurrentHashMap<String, Map<String, String>>()
     val pendingTurnFilesBySession = ConcurrentHashMap<String, Set<String>>()
 
     private val diffApplyRevisionBySession = ConcurrentHashMap<String, Long>()
@@ -202,16 +198,6 @@ internal class StateStore {
         }
 
         lastAfterBySessionAndFile[sessionId] = computedState.nextAfterByFile
-
-        // Merge server-intended "after AI" content — kept for diff viewer display.
-        val previousServerAfter = serverAfterBySessionAndFile[sessionId] ?: emptyMap()
-        serverAfterBySessionAndFile[sessionId] = mergeMapByProcessedPaths(
-            previous = previousServerAfter,
-            processedPaths = computedState.processedPaths,
-            next = computedState.newServerAfterByFile,
-            replaceAll = fromHistory,
-        )
-
         val previousState = SessionStateSnapshot(
             hunks = hunksBySessionAndFile[sessionId] ?: emptyMap(),
             liveHunks = liveHunksBySessionAndFile[sessionId] ?: emptyMap(),
@@ -332,7 +318,6 @@ internal class StateStore {
         addedBySession.clear()
         baselineBeforeBySessionAndFile.clear()
         lastAfterBySessionAndFile.clear()
-        serverAfterBySessionAndFile.clear()
         pendingTurnFilesBySession.clear()
         diffApplyRevisionBySession.clear()
         selectedSessionId = null

src/test/kotlin/com/ashotn/opencode/relay/core/DiffPipelineHarness.kt

@@ -61,7 +61,6 @@ internal class DiffPipelineHarness(
 
     fun applySessionDiff(
         files: List<Pair<String, SessionDiffStatus>>,
-        serverAfterByFile: Map<String, String> = emptyMap(),
     ): StateStore.SessionDiffCommitResult? {
         val decision = eventReducer.beginSessionDiffApply(
             stateStore = stateStore,
@@ -88,7 +87,7 @@ internal class DiffPipelineHarness(
                 OpenCodeEvent.SessionDiffFile(
                     file = abs(relPath),
                     before = "",
-                    after = serverAfterByFile[abs(relPath)] ?: "",
+                    after = "",
                     additions = 0,
                     deletions = 0,
                     status = status,
@@ -141,7 +140,4 @@ internal class DiffPipelineHarness(
 
     fun baseline(relPath: String): String? =
         stateStore.baselineBeforeBySessionAndFile[sessionId]?.get(abs(relPath))
-
-    fun serverAfter(relPath: String): String? =
-        stateStore.serverAfterBySessionAndFile[sessionId]?.get(abs(relPath))
 }

src/test/kotlin/com/ashotn/opencode/relay/core/SessionDiffPipelineTest.kt

@@ -317,42 +317,6 @@ class SessionDiffPipelineTest {
     //   4. The "After AI" panel must be empty.
     //      If it still shows the joke from turn 1, this invariant is violated.
     // -------------------------------------------------------------------------
-    @Test
-    fun `After AI panel must be empty when AI empties a file`() {
-        val file = "note.md"
-        val originalContent = "# Notes\n\nSome original text.\n"
-        val withJoke = originalContent + "\nWhy do Java developers wear glasses? Because they can't C#.\n"
-
-        // Turn 1: AI adds a joke — server sends non-empty after
-        h.disk[h.abs(file)] = withJoke
-        h.commitTurnPatch(listOf(file))
-        h.applySessionDiff(
-            files = listOf(file to SessionDiffStatus.MODIFIED),
-            serverAfterByFile = mapOf(h.abs(file) to withJoke),
-        )
-        assertEquals(
-            withJoke, h.serverAfter(file),
-            "after turn 1: serverAfter should hold the joke content"
-        )
-
-        // Turn 2: AI empties the file — server sends empty string as after
-        h.disk[h.abs(file)] = ""
-        h.commitTurnPatch(listOf(file))
-        h.applySessionDiff(
-            files = listOf(file to SessionDiffStatus.MODIFIED),
-            serverAfterByFile = mapOf(h.abs(file) to ""),
-        )
-
-        // The "After AI" content shown in the diff viewer must be empty string,
-        // not the stale joke content from turn 1.
-        assertEquals(
-            "",
-            h.serverAfter(file),
-            "After AI panel must show empty string when AI emptied the file, " +
-                    "but serverAfter still holds stale content: '${h.serverAfter(file)}'",
-        )
-    }
-
     // -------------------------------------------------------------------------
     // A file the AI modified must still appear in the session's file count even
     // when the diff computation throws an unexpected error. If hunk computation
@@ -382,7 +346,6 @@ class SessionDiffPipelineTest {
         zeroHunkHarness.commitTurnPatch(listOf(file))
         zeroHunkHarness.applySessionDiff(
             files = listOf(file to SessionDiffStatus.MODIFIED),
-            serverAfterByFile = mapOf(zeroHunkHarness.abs(file) to "line1\n"),
         )
 
         // The file was reported as MODIFIED — it must still be counted.
@@ -421,7 +384,6 @@ class SessionDiffPipelineTest {
         h.commitTurnPatch(listOf(file))
         h.applySessionDiff(
             files = listOf(file to SessionDiffStatus.MODIFIED),
-            serverAfterByFile = mapOf(h.abs(file) to aiContent),
         )
         assertEquals(1, h.trackedFileCount(), "file should be tracked after AI wrote to it")