ADFA-4128: apply the mtime margin when the rebuild holds Unknown

absorbEchoesLocked treated a held ChangedFiles.Unknown as "every file is already held"
and skipped the granularity margin for all of them. After an external Gradle build
untrusted the baseline (pending = Unknown) and a rebuild started, a .kt saved 0.5 s
into the rebuild on a 1 s-mtime filesystem stamped a whole second before the start,
was absorbed, and onBaselineReset dropped it - the edit was never built.

An Unknown held set names no file, so nothing proves an arrival is an echo; only an
enumerated held set keeps the exact cutoff. New test pins the Unknown case; a second
new test pins the margin's upper bound (an 8_000 stamp against a 10_000 start absorbs),
which with the existing 9_000 case fixes the constant at 2 s.

Adversarial review 2026-09-04, finding #9 on 60d5a27ca.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XkGof8cLt23LkxZ8MKzin2

Author: fryanpan

quickbuild/core/src/main/java/org/appdevforall/cotg/quickbuild/domain/reload/LiveReloadOrchestrator.kt

@@ -507,6 +507,9 @@ class LiveReloadOrchestrator(
 	 * arrival is the echo of the save the rebuild is absorbing, and stranding that echo is
 	 * the spurious invalidation this split exists to prevent. The residual is a re-edit of a
 	 * held file within the margin after the start on a coarse filesystem, which absorbs.
+	 * Only an enumerated held set earns that: a held [ChangedFiles.Unknown] (an untrusted
+	 * baseline handed to the rebuild) names no file, so nothing proves an arrival is an echo,
+	 * and every truncated mtime gets the margin - one spare build rather than a dropped edit.
 	 *
 	 * The absorbed part joins [awaitingAbsorption] via [ChangedFiles.plus], NOT
 	 * [unionPendingLocked]: this rebuild IS the Gradle build these files would demand, so
@@ -522,7 +525,7 @@ class LiveReloadOrchestrator(
 		val absorbed =
 			changes.files.filterTo(mutableSetOf()) { file ->
 				val mtime = fileLastModified(file)
-				val heldAlready = held !is ChangedFiles.Known || file in held.files
+				val heldAlready = held is ChangedFiles.Known && file in held.files
 				val truncated = mtime % 1_000L == 0L
 				val cutoff =
 					if (heldAlready || !truncated) {

quickbuild/core/src/test/java/org/appdevforall/cotg/quickbuild/domain/reload/LiveReloadOrchestratorTest.kt

@@ -755,6 +755,62 @@ class LiveReloadOrchestratorTest {
 			assertThat(executor.requests[0].changes).isEqualTo(known(srcA))
 		}
 
+	@Test
+	fun `a truncated mtime a full margin before the start is absorbed - the margin is two seconds, not more`() =
+		runTest {
+			// The test above pins the margin at more than 1 s (a 9_000 stamp stays pending).
+			// This one pins the other side: a whole-second stamp exactly 2 s before the start
+			// is inside the cutoff and absorbs, so the constant cannot silently grow past 2 s
+			// and strand a genuinely older save. Together they fix MTIME_GRANULARITY_MARGIN_MILLIS
+			// at 2_000 to within the whole-second grain the filesystems involved use.
+			val executor = GatedExecutor()
+			val orchestrator =
+				LiveReloadOrchestrator(
+					executor,
+					ChangeClassifier(),
+					backgroundScope,
+					wallClock = { 10_000L },
+					fileLastModified = { file -> if (file.path == srcA) 8_000L else 0L },
+				) {}
+
+			orchestrator.onFilesChanged(known("app/src/main/AndroidManifest.xml"))
+			runCurrent()
+			orchestrator.onProxyAppRebuildStarted()
+			orchestrator.onFilesChanged(known(srcA))
+			orchestrator.onBaselineReset()
+			runCurrent()
+
+			assertThat(executor.requests).isEmpty()
+		}
+
+	@Test
+	fun `a mid-rebuild edit gets the margin when the rebuild holds Unknown - nothing there proves it is an echo`() =
+		runTest {
+			// An external Gradle build untrusts the baseline (pending becomes Unknown), a rebuild
+			// then starts and takes that Unknown as its held set. A .kt saved 0.5 s into the
+			// rebuild on a 1 s-mtime filesystem reports a whole-second stamp before the start.
+			// Treating "held is Unknown" as "every file is held" skipped the margin, absorbed
+			// the save, and onBaselineReset dropped it - the edit was never built.
+			val executor = GatedExecutor()
+			val orchestrator =
+				LiveReloadOrchestrator(
+					executor,
+					ChangeClassifier(),
+					backgroundScope,
+					wallClock = { 10_000L },
+					fileLastModified = { file -> if (file.path == srcA) 9_000L else 0L },
+				) {}
+
+			orchestrator.onBaselineUntrusted()
+			orchestrator.onProxyAppRebuildStarted()
+			orchestrator.onFilesChanged(known(srcA))
+			orchestrator.onBaselineReset()
+			runCurrent()
+
+			assertThat(executor.requests).hasSize(1)
+			assertThat(executor.requests[0].changes).isEqualTo(known(srcA))
+		}
+
 	@Test
 	fun `a mid-rebuild file with no readable mtime stays pending - nothing proves it predates the read`() =
 		runTest {