ADFA-4128 (2/11): address CodeRabbit review

- F1714-1 publish the FeatureFlags snapshot with @volatile
- F1714-3 assert both Quick Build sentinels turn their own flag on
- F1714-4 make the ADFA-4328 repro prove the worker actually parked
- F1714-5 replace the em dash in the ContentReadWrite KDoc

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FstXxJ5cwWPcvmhZ9vJgJ7

Author: fryanpan

common/src/main/java/com/itsaky/androidide/utils/FeatureFlags.kt

@@ -40,6 +40,11 @@ object FeatureFlags {
 	private val logger = LoggerFactory.getLogger(FeatureFlags::class.java)
 
 	private val mutex = Mutex()
+
+	// The getters below read this without the mutex the sole writer holds. FlagsCache is
+	// immutable, so publishing the reference is the whole fix - without it a reader can keep
+	// seeing the direct-boot all-false snapshot after refresh() has replaced it.
+	@Volatile
 	private var flags = FlagsCache.DEFAULT
 
 	/**

common/src/test/java/com/itsaky/androidide/utils/FeatureFlagsTest.kt

@@ -99,4 +99,30 @@ class FeatureFlagsTest {
 
 			assertThat(FeatureFlags.isExperimentsEnabled).isFalse()
 		}
+
+	// The two Quick Build sentinels get a test each. Nothing else asserts that either
+	// filename maps to its flag, so a typo or a swapped pair would leave the bench harness
+	// silently unarmed and this suite green - visible only as a device run with no events.
+
+	@Test
+	fun `the qbbench sentinel arms the bench hooks and nothing else`() =
+		runTest {
+			tempFolder.newFile("CodeOnTheGo.qbbench")
+
+			FeatureFlags.initialize()
+
+			assertThat(FeatureFlags.isQuickBuildBenchEnabled).isTrue()
+			assertThat(FeatureFlags.isQuickBuildWarmCompileDisabled).isFalse()
+		}
+
+	@Test
+	fun `the qbnoseed sentinel disables warm compile and nothing else`() =
+		runTest {
+			tempFolder.newFile("CodeOnTheGo.qbnoseed")
+
+			FeatureFlags.initialize()
+
+			assertThat(FeatureFlags.isQuickBuildWarmCompileDisabled).isTrue()
+			assertThat(FeatureFlags.isQuickBuildBenchEnabled).isFalse()
+		}
 }

common/src/test/java/com/itsaky/androidide/utils/KeyedDebouncingActionCancelTest.kt

@@ -1,12 +1,14 @@
 package com.itsaky.androidide.utils
 
 import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.channels.ClosedReceiveChannelException
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
 import org.junit.Test
 import java.util.concurrent.atomic.AtomicReference
 import kotlin.coroutines.CoroutineContext
@@ -35,23 +37,33 @@ class KeyedDebouncingActionCancelTest {
 
 			val ctx: CoroutineContext = scope.coroutineContext
 
+			// Signalled from inside the action, so the test knows the worker really got that
+			// far. A fixed delay cannot tell "the worker is parked on receive()" apart from
+			// "the worker never started" - and in the second case the cancellation raises a
+			// CancellationException the handler never sees, so the repro silently does not run
+			// and the test still reports green.
+			val actionRan = CompletableDeferred<Unit>()
+
 			val debouncer =
 				KeyedDebouncingAction<String>(
 					scope = scope,
 					debounceDuration = 50.milliseconds,
 					actionContext = ctx,
-					// Never invoked: the worker is cancelled while parked on receive().
-					action = { _, _ -> },
+					action = { _, _ -> actionRan.complete(Unit) },
 				)
 
 			// schedule() creates the entry + launches the worker. With a CONFLATED channel and
-			// no further sends, the worker debounces the single key, runs the (empty) action,
-			// then loops back and parks on channel.receive() waiting for the next key.
+			// no further sends, the worker debounces the single key, runs the action, then
+			// loops back and parks on channel.receive() waiting for the next key.
 			debouncer.schedule("k")
 
-			// Give the worker time to: receive "k", run the empty action, loop, and PARK on
-			// the next channel.receive(). 200ms >> 50ms debounce window.
-			delay(200)
+			// Fails loudly rather than passing vacuously if the worker never reached the action.
+			withTimeout(5_000) { actionRan.await() }
+			assertThat(actionRan.isCompleted).isTrue()
+
+			// The action has returned; the remaining hop is joining the action job and looping
+			// back to the park, which has no observable signal of its own.
+			delay(100)
 
 			// Cancel the entry while the worker is parked on receive().
 			debouncer.cancelPending("k")

editor/src/main/java/com/itsaky/androidide/editor/utils/ContentReadWrite.kt

@@ -34,7 +34,7 @@ object ContentReadWrite {
 	/**
 	 * Write this [Content] to the given [File].
 	 *
-	 * Writes IN PLACE — opens [file] directly and truncates + writes sequentially; this is
+	 * Writes IN PLACE - opens [file] directly and truncates + writes sequentially; this is
 	 * NOT a temp-file-then-rename swap. A filesystem watcher observing a save from this
 	 * method sees the target path itself change, never a sibling temp file (that pattern
 	 * is specific to EXTERNAL tools like `sed -i` or `git checkout`).